]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use the right number in the tarball filename
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp,
2893
2894 wxArrayDouble2PyList_helper,
2895 wxPoint2D_LIST_helper
2896 };
2897
2898 #endif
2899
2900
2901 #if !WXWIN_COMPATIBILITY_2_4
2902 #define wxHIDE_READONLY 0
2903 #endif
2904
2905
2906 #define SWIG_From_long PyInt_FromLong
2907
2908
2909 SWIGINTERNINLINE PyObject *
2910 SWIG_From_int (int value)
2911 {
2912 return SWIG_From_long (value);
2913 }
2914
2915 static const wxString wxPyEmptyString(wxEmptyString);
2916 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2917 return self->GetClassInfo()->GetClassName();
2918 }
2919 SWIGINTERN void wxObject_Destroy(wxObject *self){
2920 delete self;
2921 }
2922
2923 #ifndef __WXMAC__
2924 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2925 #endif
2926
2927
2928 #include <limits.h>
2929 #ifndef LLONG_MIN
2930 # define LLONG_MIN LONG_LONG_MIN
2931 #endif
2932 #ifndef LLONG_MAX
2933 # define LLONG_MAX LONG_LONG_MAX
2934 #endif
2935 #ifndef ULLONG_MAX
2936 # define ULLONG_MAX ULONG_LONG_MAX
2937 #endif
2938
2939
2940 SWIGINTERN int
2941 SWIG_AsVal_long (PyObject* obj, long* val)
2942 {
2943 if (PyNumber_Check(obj)) {
2944 if (val) *val = PyInt_AsLong(obj);
2945 return SWIG_OK;
2946 }
2947 return SWIG_TypeError;
2948 }
2949
2950
2951 SWIGINTERN int
2952 SWIG_AsVal_int (PyObject * obj, int *val)
2953 {
2954 long v;
2955 int res = SWIG_AsVal_long (obj, &v);
2956 if (SWIG_IsOK(res)) {
2957 if ((v < INT_MIN || v > INT_MAX)) {
2958 return SWIG_OverflowError;
2959 } else {
2960 if (val) *val = static_cast< int >(v);
2961 }
2962 }
2963 return res;
2964 }
2965
2966 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2967 wxSize temp, *obj = &temp;
2968 if ( other == Py_None ) return false;
2969 if ( ! wxSize_helper(other, &obj) ) {
2970 PyErr_Clear();
2971 return false;
2972 }
2973 return self->operator==(*obj);
2974 }
2975 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return true;
2978 if ( ! wxSize_helper(other, &obj)) {
2979 PyErr_Clear();
2980 return true;
2981 }
2982 return self->operator!=(*obj);
2983 }
2984
2985 #include <float.h>
2986
2987
2988 SWIGINTERN int
2989 SWIG_AsVal_double (PyObject *obj, double* val)
2990 {
2991 if (PyNumber_Check(obj)) {
2992 if (val) *val = PyFloat_AsDouble(obj);
2993 return SWIG_OK;
2994 }
2995 return SWIG_TypeError;
2996 }
2997
2998
2999 SWIGINTERN int
3000 SWIG_AsVal_float (PyObject * obj, float *val)
3001 {
3002 double v;
3003 int res = SWIG_AsVal_double (obj, &v);
3004 if (SWIG_IsOK(res)) {
3005 if ((v < -FLT_MAX || v > FLT_MAX)) {
3006 return SWIG_OverflowError;
3007 } else {
3008 if (val) *val = static_cast< float >(v);
3009 }
3010 }
3011 return res;
3012 }
3013
3014 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3015 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3016 PyObject* tup = PyTuple_New(2);
3017 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3018 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3019 wxPyEndBlockThreads(blocked);
3020 return tup;
3021 }
3022
3023 #define SWIG_From_double PyFloat_FromDouble
3024
3025 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3026 wxRealPoint temp, *obj = &temp;
3027 if ( other == Py_None ) return false;
3028 if ( ! wxRealPoint_helper(other, &obj) ) {
3029 PyErr_Clear();
3030 return false;
3031 }
3032 return self->operator==(*obj);
3033 }
3034 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return true;
3037 if ( ! wxRealPoint_helper(other, &obj)) {
3038 PyErr_Clear();
3039 return true;
3040 }
3041 return self->operator!=(*obj);
3042 }
3043 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3044 self->x = x;
3045 self->y = y;
3046 }
3047 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 PyObject* tup = PyTuple_New(2);
3050 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3051 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3052 wxPyEndBlockThreads(blocked);
3053 return tup;
3054 }
3055 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3056 wxPoint temp, *obj = &temp;
3057 if ( other == Py_None ) return false;
3058 if ( ! wxPoint_helper(other, &obj) ) {
3059 PyErr_Clear();
3060 return false;
3061 }
3062 return self->operator==(*obj);
3063 }
3064 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return true;
3067 if ( ! wxPoint_helper(other, &obj)) {
3068 PyErr_Clear();
3069 return true;
3070 }
3071 return self->operator!=(*obj);
3072 }
3073 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3074 self->x = x;
3075 self->y = y;
3076 }
3077 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3079 PyObject* tup = PyTuple_New(2);
3080 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3081 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3082 wxPyEndBlockThreads(blocked);
3083 return tup;
3084 }
3085 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3086 wxRect temp, *obj = &temp;
3087 if ( other == Py_None ) return false;
3088 if ( ! wxRect_helper(other, &obj) ) {
3089 PyErr_Clear();
3090 return false;
3091 }
3092 return self->operator==(*obj);
3093 }
3094 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return true;
3097 if ( ! wxRect_helper(other, &obj)) {
3098 PyErr_Clear();
3099 return true;
3100 }
3101 return self->operator!=(*obj);
3102 }
3103 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3104 self->x = x;
3105 self->y = y;
3106 self->width = width;
3107 self->height = height;
3108 }
3109 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3111 PyObject* tup = PyTuple_New(4);
3112 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3113 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3114 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3115 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3116 wxPyEndBlockThreads(blocked);
3117 return tup;
3118 }
3119
3120 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3121 wxRegion reg1(*r1);
3122 wxRegion reg2(*r2);
3123 wxRect dest(0,0,0,0);
3124 PyObject* obj;
3125
3126 reg1.Intersect(reg2);
3127 dest = reg1.GetBox();
3128
3129 if (dest != wxRect(0,0,0,0)) {
3130 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3131 wxRect* newRect = new wxRect(dest);
3132 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3133 wxPyEndBlockThreads(blocked);
3134 return obj;
3135 }
3136 Py_INCREF(Py_None);
3137 return Py_None;
3138 }
3139
3140 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3141 wxPoint2D temp, *obj = &temp;
3142 if ( other == Py_None ) return false;
3143 if ( ! wxPoint2D_helper(other, &obj) ) {
3144 PyErr_Clear();
3145 return false;
3146 }
3147 return self->operator==(*obj);
3148 }
3149 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return true;
3152 if ( ! wxPoint2D_helper(other, &obj)) {
3153 PyErr_Clear();
3154 return true;
3155 }
3156 return self->operator!=(*obj);
3157 }
3158 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3159 self->m_x = x;
3160 self->m_y = y;
3161 }
3162 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3164 PyObject* tup = PyTuple_New(2);
3165 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3166 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3167 wxPyEndBlockThreads(blocked);
3168 return tup;
3169 }
3170
3171 #include "wx/wxPython/pyistream.h"
3172
3173 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3174 wxInputStream* wxis = wxPyCBInputStream::create(p);
3175 if (wxis)
3176 return new wxPyInputStream(wxis);
3177 else
3178 return NULL;
3179 }
3180
3181 SWIGINTERN swig_type_info*
3182 SWIG_pchar_descriptor()
3183 {
3184 static int init = 0;
3185 static swig_type_info* info = 0;
3186 if (!init) {
3187 info = SWIG_TypeQuery("_p_char");
3188 init = 1;
3189 }
3190 return info;
3191 }
3192
3193
3194 SWIGINTERNINLINE PyObject *
3195 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3196 {
3197 if (carray) {
3198 if (size > INT_MAX) {
3199 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3200 return pchar_descriptor ?
3201 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3202 } else {
3203 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3204 }
3205 } else {
3206 return SWIG_Py_Void();
3207 }
3208 }
3209
3210
3211 SWIGINTERNINLINE PyObject *
3212 SWIG_From_char (char c)
3213 {
3214 return SWIG_FromCharPtrAndSize(&c,1);
3215 }
3216
3217
3218 SWIGINTERNINLINE PyObject*
3219 SWIG_From_unsigned_SS_long (unsigned long value)
3220 {
3221 return (value > LONG_MAX) ?
3222 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3223 }
3224
3225
3226 SWIGINTERNINLINE PyObject *
3227 SWIG_From_size_t (size_t value)
3228 {
3229 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3230 }
3231
3232
3233 SWIGINTERN int
3234 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3235 {
3236 if (PyString_Check(obj)) {
3237 char *cstr; Py_ssize_t len;
3238 PyString_AsStringAndSize(obj, &cstr, &len);
3239 if (cptr) {
3240 if (alloc) {
3241 /*
3242 In python the user should not be able to modify the inner
3243 string representation. To warranty that, if you define
3244 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3245 buffer is always returned.
3246
3247 The default behavior is just to return the pointer value,
3248 so, be careful.
3249 */
3250 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3251 if (*alloc != SWIG_OLDOBJ)
3252 #else
3253 if (*alloc == SWIG_NEWOBJ)
3254 #endif
3255 {
3256 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3257 *alloc = SWIG_NEWOBJ;
3258 }
3259 else {
3260 *cptr = cstr;
3261 *alloc = SWIG_OLDOBJ;
3262 }
3263 } else {
3264 *cptr = PyString_AsString(obj);
3265 }
3266 }
3267 if (psize) *psize = len + 1;
3268 return SWIG_OK;
3269 } else {
3270 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3271 if (pchar_descriptor) {
3272 void* vptr = 0;
3273 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3274 if (cptr) *cptr = (char *) vptr;
3275 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3276 if (alloc) *alloc = SWIG_OLDOBJ;
3277 return SWIG_OK;
3278 }
3279 }
3280 }
3281 return SWIG_TypeError;
3282 }
3283
3284
3285 SWIGINTERN int
3286 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3287 {
3288 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3289 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3290 if (SWIG_IsOK(res)) {
3291 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3292 if (csize <= size) {
3293 if (val) {
3294 if (csize) memcpy(val, cptr, csize*sizeof(char));
3295 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3296 }
3297 if (alloc == SWIG_NEWOBJ) {
3298 delete[] cptr;
3299 res = SWIG_DelNewMask(res);
3300 }
3301 return res;
3302 }
3303 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3304 }
3305 return SWIG_TypeError;
3306 }
3307
3308
3309 SWIGINTERN int
3310 SWIG_AsVal_char (PyObject * obj, char *val)
3311 {
3312 int res = SWIG_AsCharArray(obj, val, 1);
3313 if (!SWIG_IsOK(res)) {
3314 long v;
3315 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3316 if (SWIG_IsOK(res)) {
3317 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3318 if (val) *val = static_cast< char >(v);
3319 } else {
3320 res = SWIG_OverflowError;
3321 }
3322 }
3323 }
3324 return res;
3325 }
3326
3327 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3328 // We use only strings for the streams, not unicode
3329 PyObject* str = PyObject_Str(obj);
3330 if (! str) {
3331 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3332 return;
3333 }
3334 self->Write(PyString_AS_STRING(str),
3335 PyString_GET_SIZE(str));
3336 Py_DECREF(str);
3337 }
3338
3339 #include "wx/wxPython/pyistream.h"
3340
3341
3342 class wxPyFileSystemHandler : public wxFileSystemHandler
3343 {
3344 public:
3345 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3346
3347 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3348 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3349 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3350 DEC_PYCALLBACK_STRING__pure(FindNext);
3351
3352 wxString GetProtocol(const wxString& location) {
3353 return wxFileSystemHandler::GetProtocol(location);
3354 }
3355
3356 wxString GetLeftLocation(const wxString& location) {
3357 return wxFileSystemHandler::GetLeftLocation(location);
3358 }
3359
3360 wxString GetAnchor(const wxString& location) {
3361 return wxFileSystemHandler::GetAnchor(location);
3362 }
3363
3364 wxString GetRightLocation(const wxString& location) {
3365 return wxFileSystemHandler::GetRightLocation(location);
3366 }
3367
3368 wxString GetMimeTypeFromExt(const wxString& location) {
3369 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3370 }
3371
3372 PYPRIVATE;
3373 };
3374
3375
3376 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3377 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3378 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3379 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3380
3381
3382 SWIGINTERN int
3383 SWIG_AsVal_bool (PyObject *obj, bool *val)
3384 {
3385 if (obj == Py_True) {
3386 if (val) *val = true;
3387 return SWIG_OK;
3388 } else if (obj == Py_False) {
3389 if (val) *val = false;
3390 return SWIG_OK;
3391 } else {
3392 long v = 0;
3393 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3394 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3395 return res;
3396 }
3397 }
3398
3399 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3400 wxFileName fname = wxFileSystem::URLToFileName(url);
3401 return fname.GetFullPath();
3402 }
3403
3404 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3405 wxImage& image,
3406 long type) {
3407 wxMemoryFSHandler::AddFile(filename, image, type);
3408 }
3409
3410 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3411 const wxBitmap& bitmap,
3412 long type) {
3413 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3414 }
3415
3416 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3417 PyObject* data) {
3418 if (! PyString_Check(data)) {
3419 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3420 "Expected string object"));
3421 return;
3422 }
3423
3424 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3425 void* ptr = (void*)PyString_AsString(data);
3426 size_t size = PyString_Size(data);
3427 wxPyEndBlockThreads(blocked);
3428
3429 wxMemoryFSHandler::AddFile(filename, ptr, size);
3430 }
3431
3432
3433 #include "wx/wxPython/pyistream.h"
3434
3435
3436 SWIGINTERN int
3437 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3438 {
3439 long v = 0;
3440 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3441 return SWIG_TypeError;
3442 }
3443 else if (val)
3444 *val = (unsigned long)v;
3445 return SWIG_OK;
3446 }
3447
3448
3449 SWIGINTERN int
3450 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3451 {
3452 unsigned long v;
3453 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3454 if (SWIG_IsOK(res)) {
3455 if ((v > UCHAR_MAX)) {
3456 return SWIG_OverflowError;
3457 } else {
3458 if (val) *val = static_cast< unsigned char >(v);
3459 }
3460 }
3461 return res;
3462 }
3463
3464
3465 SWIGINTERNINLINE PyObject *
3466 SWIG_From_unsigned_SS_char (unsigned char value)
3467 {
3468 return SWIG_From_unsigned_SS_long (value);
3469 }
3470
3471 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3472 wxImageHistogramEntry e = (*self)[key];
3473 return e.value;
3474 }
3475 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3476 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3477 wxImageHistogramEntry e = (*self)[key];
3478 return e.value;
3479 }
3480 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3481 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3482 colour.Green(),
3483 colour.Blue());
3484 wxImageHistogramEntry e = (*self)[key];
3485 return e.value;
3486 }
3487
3488 // Pull the nested class out to the top level for SWIG's sake
3489 #define wxImage_RGBValue wxImage::RGBValue
3490 #define wxImage_HSVValue wxImage::HSVValue
3491
3492 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3493 if (width > 0 && height > 0)
3494 return new wxImage(width, height, clear);
3495 else
3496 return new wxImage;
3497 }
3498 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3499 return new wxImage(bitmap.ConvertToImage());
3500 }
3501 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3502 if (DATASIZE != width*height*3) {
3503 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3504 return NULL;
3505 }
3506
3507 // Copy the source data so the wxImage can clean it up later
3508 buffer copy = (buffer)malloc(DATASIZE);
3509 if (copy == NULL) {
3510 wxPyBLOCK_THREADS(PyErr_NoMemory());
3511 return NULL;
3512 }
3513 memcpy(copy, data, DATASIZE);
3514 return new wxImage(width, height, copy, false);
3515 }
3516 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3517 if (DATASIZE != width*height*3) {
3518 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3519 return NULL;
3520 }
3521 if (ALPHASIZE != width*height) {
3522 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3523 return NULL;
3524 }
3525
3526 // Copy the source data so the wxImage can clean it up later
3527 buffer dcopy = (buffer)malloc(DATASIZE);
3528 if (dcopy == NULL) {
3529 wxPyBLOCK_THREADS(PyErr_NoMemory());
3530 return NULL;
3531 }
3532 memcpy(dcopy, data, DATASIZE);
3533
3534 buffer acopy = (buffer)malloc(ALPHASIZE);
3535 if (acopy == NULL) {
3536 wxPyBLOCK_THREADS(PyErr_NoMemory());
3537 return NULL;
3538 }
3539 memcpy(acopy, alpha, ALPHASIZE);
3540
3541 return new wxImage(width, height, dcopy, acopy, false);
3542 }
3543 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3544 wxSize size(self->GetWidth(), self->GetHeight());
3545 return size;
3546 }
3547 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3548 buffer data = self->GetData();
3549 int len = self->GetWidth() * self->GetHeight() * 3;
3550 PyObject* rv;
3551 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3552 return rv;
3553 }
3554 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3555 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3556 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3557 return;
3558 }
3559 buffer copy = (buffer)malloc(DATASIZE);
3560 if (copy == NULL) {
3561 wxPyBLOCK_THREADS(PyErr_NoMemory());
3562 return;
3563 }
3564 memcpy(copy, data, DATASIZE);
3565 self->SetData(copy, false);
3566 // wxImage takes ownership of copy...
3567 }
3568 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3569 buffer data = self->GetData();
3570 int len = self->GetWidth() * self->GetHeight() * 3;
3571 PyObject* rv;
3572 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3573 return rv;
3574 }
3575 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3576 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3577 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3578 return;
3579 }
3580 self->SetData(data, true);
3581 }
3582 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3583 buffer data = self->GetAlpha();
3584 if (! data) {
3585 RETURN_NONE();
3586 } else {
3587 int len = self->GetWidth() * self->GetHeight();
3588 PyObject* rv;
3589 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3590 return rv;
3591 }
3592 }
3593 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3594 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3596 return;
3597 }
3598 buffer acopy = (buffer)malloc(ALPHASIZE);
3599 if (acopy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(acopy, alpha, ALPHASIZE);
3604 self->SetAlpha(acopy, false);
3605 // wxImage takes ownership of acopy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3608 buffer data = self->GetAlpha();
3609 int len = self->GetWidth() * self->GetHeight();
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3615 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3617 return;
3618 }
3619 self->SetAlpha(alpha, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetHandlers(){
3622 wxList& list = wxImage::GetHandlers();
3623 return wxPy_ConvertList(&list);
3624 }
3625 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3626 wxBitmap bitmap(*self, depth);
3627 return bitmap;
3628 }
3629 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3630 wxImage mono = self->ConvertToMono( red, green, blue );
3631 wxBitmap bitmap( mono, 1 );
3632 return bitmap;
3633 }
3634
3635 wxImage* _ImageFromBuffer(int width, int height,
3636 buffer data, int DATASIZE,
3637 buffer alpha=NULL, int ALPHASIZE=0)
3638 {
3639 if (DATASIZE != width*height*3) {
3640 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3641 return NULL;
3642 }
3643 if (alpha != NULL) {
3644 if (ALPHASIZE != width*height) {
3645 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3646 return NULL;
3647 }
3648 return new wxImage(width, height, data, alpha, true);
3649 }
3650 return new wxImage(width, height, data, true);
3651 }
3652
3653 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3654 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3656 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3660 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3661 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3662 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3663 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3664 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3665 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3666 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3667 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3668
3669 #include <wx/quantize.h>
3670
3671 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3672 return wxQuantize::Quantize(src, dest,
3673 //NULL, // palette
3674 desiredNoColours,
3675 NULL, // eightBitData
3676 flags);
3677 }
3678 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3679 if (PyCallable_Check(func)) {
3680 self->Connect(id, lastId, eventType,
3681 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3682 new wxPyCallback(func));
3683 }
3684 else if (func == Py_None) {
3685 self->Disconnect(id, lastId, eventType,
3686 (wxObjectEventFunction)
3687 &wxPyCallback::EventThunker);
3688 }
3689 else {
3690 wxPyBLOCK_THREADS(
3691 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3692 }
3693 }
3694 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3695 return self->Disconnect(id, lastId, eventType,
3696 (wxObjectEventFunction)
3697 &wxPyCallback::EventThunker);
3698 }
3699 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3700 if (_self && _self != Py_None) {
3701 self->SetClientObject(new wxPyOORClientData(_self, incref));
3702 }
3703 else {
3704 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3705 if (data) {
3706 self->SetClientObject(NULL); // This will delete it too
3707 }
3708 }
3709 }
3710
3711 #if ! wxUSE_HOTKEY
3712 #define wxEVT_HOTKEY -9999
3713 #endif
3714
3715 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3716 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3717 if (data) {
3718 Py_INCREF(data->m_obj);
3719 return data->m_obj;
3720 } else {
3721 Py_INCREF(Py_None);
3722 return Py_None;
3723 }
3724 }
3725 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3726 wxPyClientData* data = new wxPyClientData(clientData);
3727 self->SetClientObject(data);
3728 }
3729 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3730 #if wxUSE_UNICODE
3731 return self->GetUnicodeKey();
3732 #else
3733 return 0;
3734 #endif
3735 }
3736 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3737 #if wxUSE_UNICODE
3738 self->m_uniChar = uniChar;
3739 #endif
3740 }
3741
3742 SWIGINTERNINLINE PyObject *
3743 SWIG_From_unsigned_SS_int (unsigned int value)
3744 {
3745 return SWIG_From_unsigned_SS_long (value);
3746 }
3747
3748
3749 SWIGINTERN int
3750 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3751 {
3752 unsigned long v;
3753 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3754 if (SWIG_IsOK(res)) {
3755 if ((v > UINT_MAX)) {
3756 return SWIG_OverflowError;
3757 } else {
3758 if (val) *val = static_cast< unsigned int >(v);
3759 }
3760 }
3761 return res;
3762 }
3763
3764 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3765 self->m_size = size;
3766 }
3767 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3768 int count = self->GetNumberOfFiles();
3769 wxString* files = self->GetFiles();
3770 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3771 PyObject* list = PyList_New(count);
3772
3773 if (!list) {
3774 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3775 wxPyEndBlockThreads(blocked);
3776 return NULL;
3777 }
3778
3779 for (int i=0; i<count; i++) {
3780 PyList_SetItem(list, i, wx2PyString(files[i]));
3781 }
3782 wxPyEndBlockThreads(blocked);
3783 return list;
3784 }
3785
3786
3787 SWIGINTERN wxPyApp *new_wxPyApp(){
3788 wxPythonApp = new wxPyApp();
3789 return wxPythonApp;
3790 }
3791 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3792 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3793 return wxPyTestDisplayAvailable();
3794 }
3795
3796 void wxApp_CleanUp() {
3797 __wxPyCleanup();
3798 }
3799
3800
3801 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3802
3803
3804
3805
3806
3807 SWIGINTERNINLINE PyObject *
3808 SWIG_FromCharPtr(const char *cptr)
3809 {
3810 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3811 }
3812
3813
3814 #if 0 // #ifdef __WXMAC__
3815
3816 // A dummy class that raises an exception if used...
3817 class wxEventLoop
3818 {
3819 public:
3820 wxEventLoop() { wxPyRaiseNotImplemented(); }
3821 int Run() { return 0; }
3822 void Exit(int rc = 0) {}
3823 bool Pending() const { return false; }
3824 bool Dispatch() { return false; }
3825 bool IsRunning() const { return false; }
3826 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3827 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3828 };
3829
3830 #else
3831
3832 #include <wx/evtloop.h>
3833
3834 #endif
3835
3836
3837
3838 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3839 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3840 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3841 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3842 wxWindowList& list = self->GetChildren();
3843 return wxPy_ConvertList(&list);
3844 }
3845 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3846 #if wxUSE_HOTKEY
3847 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3848 #else
3849 return false;
3850 #endif
3851 }
3852 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3853
3854
3855
3856 return false;
3857
3858 }
3859 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3860 return wxPyGetWinHandle(self);
3861 }
3862 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3863 self->AssociateHandle((WXWidget)handle);
3864 }
3865 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3866
3867 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3868 return wxWindow::FindWindowById(id, parent);
3869 }
3870
3871 wxWindow* wxFindWindowByName( const wxString& name,
3872 const wxWindow *parent = NULL ) {
3873 return wxWindow::FindWindowByName(name, parent);
3874 }
3875
3876 wxWindow* wxFindWindowByLabel( const wxString& label,
3877 const wxWindow *parent = NULL ) {
3878 return wxWindow::FindWindowByLabel(label, parent);
3879 }
3880
3881
3882 #ifdef __WXMSW__
3883 #include <wx/msw/private.h> // to get wxGetWindowId
3884 #endif
3885
3886
3887 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3888 #ifdef __WXMSW__
3889 WXHWND hWnd = (WXHWND)_hWnd;
3890 long id = wxGetWindowId(hWnd);
3891 wxWindow* win = new wxWindow;
3892 if (parent)
3893 parent->AddChild(win);
3894 win->SetEventHandler(win);
3895 win->SetHWND(hWnd);
3896 win->SetId(id);
3897 win->SubclassWin(hWnd);
3898 win->AdoptAttributesFromHWND();
3899 win->SetupColours();
3900 return win;
3901 #else
3902 wxPyRaiseNotImplemented();
3903 return NULL;
3904 #endif
3905 }
3906
3907
3908 PyObject* GetTopLevelWindows() {
3909 return wxPy_ConvertList(&wxTopLevelWindows);
3910 }
3911
3912
3913 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3915 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3916
3917 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3918
3919
3920 SWIGINTERNINLINE int
3921 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3922 {
3923 unsigned long v;
3924 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3925 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3926 return res;
3927 }
3928
3929 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3930 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3931 wxMenuItemList& list = self->GetMenuItems();
3932 return wxPy_ConvertList(&list);
3933 }
3934 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3935 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3936 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3937 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3938 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3939 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3940 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3941 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3942 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3943 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3944 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3945 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3946 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3947 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3948 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3949 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3950 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3951 static const wxString wxPyControlNameStr(wxControlNameStr);
3952 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3953 if (clientData) {
3954 wxPyClientData* data = new wxPyClientData(clientData);
3955 return self->Append(item, data);
3956 } else
3957 return self->Append(item);
3958 }
3959 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3960 if (clientData) {
3961 wxPyClientData* data = new wxPyClientData(clientData);
3962 return self->Insert(item, pos, data);
3963 } else
3964 return self->Insert(item, pos);
3965 }
3966 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3967 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3968 if (data) {
3969 Py_INCREF(data->m_obj);
3970 return data->m_obj;
3971 } else {
3972 Py_INCREF(Py_None);
3973 return Py_None;
3974 }
3975 }
3976 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3977 wxPyClientData* data = new wxPyClientData(clientData);
3978 self->SetClientObject(n, data);
3979 }
3980
3981
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(window, proportion, flag, border, data);
3990 }
3991 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3992 wxPyUserData* data = NULL;
3993 if ( userData ) {
3994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3995 data = new wxPyUserData(userData);
3996 wxPyEndBlockThreads(blocked);
3997 }
3998 return new wxSizerItem(width, height, proportion, flag, border, data);
3999 }
4000 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4001 wxPyUserData* data = NULL;
4002 if ( userData ) {
4003 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4004 data = new wxPyUserData(userData);
4005 wxPyEndBlockThreads(blocked);
4006 }
4007 return new wxSizerItem(sizer, proportion, flag, border, data);
4008 }
4009
4010 SWIGINTERNINLINE PyObject *
4011 SWIG_From_float (float value)
4012 {
4013 return SWIG_From_double (value);
4014 }
4015
4016 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4017 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4018 if (data) {
4019 Py_INCREF(data->m_obj);
4020 return data->m_obj;
4021 } else {
4022 Py_INCREF(Py_None);
4023 return Py_None;
4024 }
4025 }
4026 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 self->SetUserData(data);
4034 }
4035
4036 // Figure out the type of the sizer item
4037
4038 struct wxPySizerItemInfo {
4039 wxPySizerItemInfo()
4040 : window(NULL), sizer(NULL), gotSize(false),
4041 size(wxDefaultSize), gotPos(false), pos(-1)
4042 {}
4043
4044 wxWindow* window;
4045 wxSizer* sizer;
4046 bool gotSize;
4047 wxSize size;
4048 bool gotPos;
4049 int pos;
4050 };
4051
4052 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4053
4054 wxPySizerItemInfo info;
4055 wxSize size;
4056 wxSize* sizePtr = &size;
4057
4058 // Find out what the type of the item is
4059 // try wxWindow
4060 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4061 PyErr_Clear();
4062 info.window = NULL;
4063
4064 // try wxSizer
4065 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4066 PyErr_Clear();
4067 info.sizer = NULL;
4068
4069 // try wxSize or (w,h)
4070 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4071 info.size = *sizePtr;
4072 info.gotSize = true;
4073 }
4074
4075 // or a single int
4076 if (checkIdx && PyInt_Check(item)) {
4077 info.pos = PyInt_AsLong(item);
4078 info.gotPos = true;
4079 }
4080 }
4081 }
4082
4083 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4084 // no expected type, figure out what kind of error message to generate
4085 if ( !checkSize && !checkIdx )
4086 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4087 else if ( checkSize && !checkIdx )
4088 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4089 else if ( !checkSize && checkIdx)
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4091 else
4092 // can this one happen?
4093 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4094 }
4095
4096 return info;
4097 }
4098
4099 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4100 if (!self->GetClientObject())
4101 self->SetClientObject(new wxPyOORClientData(_self));
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4104
4105 wxPyUserData* data = NULL;
4106 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4107 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4108 if ( userData && (info.window || info.sizer || info.gotSize) )
4109 data = new wxPyUserData(userData);
4110 if ( info.sizer )
4111 PyObject_SetAttrString(item,"thisown",Py_False);
4112 wxPyEndBlockThreads(blocked);
4113
4114 // Now call the real Add method if a valid item type was found
4115 if ( info.window )
4116 return self->Add(info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Add(info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Insert method if a valid item type was found
4137 if ( info.window )
4138 return self->Insert(before, info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Insert(before, info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4148
4149 wxPyUserData* data = NULL;
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4152 if ( userData && (info.window || info.sizer || info.gotSize) )
4153 data = new wxPyUserData(userData);
4154 if ( info.sizer )
4155 PyObject_SetAttrString(item,"thisown",Py_False);
4156 wxPyEndBlockThreads(blocked);
4157
4158 // Now call the real Prepend method if a valid item type was found
4159 if ( info.window )
4160 return self->Prepend(info.window, proportion, flag, border, data);
4161 else if ( info.sizer )
4162 return self->Prepend(info.sizer, proportion, flag, border, data);
4163 else if (info.gotSize)
4164 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4165 proportion, flag, border, data);
4166 else
4167 return NULL;
4168 }
4169 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4172 wxPyEndBlockThreads(blocked);
4173 if ( info.window )
4174 return self->Remove(info.window);
4175 else if ( info.sizer )
4176 return self->Remove(info.sizer);
4177 else if ( info.gotPos )
4178 return self->Remove(info.pos);
4179 else
4180 return false;
4181 }
4182 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4183 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4184 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4185 wxPyEndBlockThreads(blocked);
4186 if ( info.window )
4187 return self->Detach(info.window);
4188 else if ( info.sizer )
4189 return self->Detach(info.sizer);
4190 else if ( info.gotPos )
4191 return self->Detach(info.pos);
4192 else
4193 return false;
4194 }
4195 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->GetItem(info.window);
4201 else if ( info.sizer )
4202 return self->GetItem(info.sizer);
4203 else if ( info.gotPos )
4204 return self->GetItem(info.pos);
4205 else
4206 return NULL;
4207 }
4208 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 self->SetItemMinSize(info.window, size);
4214 else if ( info.sizer )
4215 self->SetItemMinSize(info.sizer, size);
4216 else if ( info.gotPos )
4217 self->SetItemMinSize(info.pos, size);
4218 }
4219 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4220 wxSizerItemList& list = self->GetChildren();
4221 return wxPy_ConvertList(&list);
4222 }
4223 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4226 wxPyEndBlockThreads(blocked);
4227 if ( info.window )
4228 return self->Show(info.window, show, recursive);
4229 else if ( info.sizer )
4230 return self->Show(info.sizer, show, recursive);
4231 else if ( info.gotPos )
4232 return self->Show(info.pos, show);
4233 else
4234 return false;
4235 }
4236 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4237 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4238 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4239 wxPyEndBlockThreads(blocked);
4240 if ( info.window )
4241 return self->IsShown(info.window);
4242 else if ( info.sizer )
4243 return self->IsShown(info.sizer);
4244 else if ( info.gotPos )
4245 return self->IsShown(info.pos);
4246 else
4247 return false;
4248 }
4249
4250 // See pyclasses.h
4251 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4252 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4253 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4254
4255
4256
4257
4258 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4259 {
4260 if (source == Py_None) {
4261 **obj = wxGBPosition(-1,-1);
4262 return true;
4263 }
4264 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4265 }
4266
4267 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4268 {
4269 if (source == Py_None) {
4270 **obj = wxGBSpan(-1,-1);
4271 return true;
4272 }
4273 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4274 }
4275
4276
4277 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4278 wxGBPosition temp, *obj = &temp;
4279 if ( other == Py_None ) return false;
4280 if ( ! wxGBPosition_helper(other, &obj) ) {
4281 PyErr_Clear();
4282 return false;
4283 }
4284 return self->operator==(*obj);
4285 }
4286 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4287 wxGBPosition temp, *obj = &temp;
4288 if ( other == Py_None ) return true;
4289 if ( ! wxGBPosition_helper(other, &obj)) {
4290 PyErr_Clear();
4291 return true;
4292 }
4293 return self->operator!=(*obj);
4294 }
4295 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4296 self->SetRow(row);
4297 self->SetCol(col);
4298 }
4299 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4300 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4301 PyObject* tup = PyTuple_New(2);
4302 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4303 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4304 wxPyEndBlockThreads(blocked);
4305 return tup;
4306 }
4307 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4308 wxGBSpan temp, *obj = &temp;
4309 if ( other == Py_None ) return false;
4310 if ( ! wxGBSpan_helper(other, &obj) ) {
4311 PyErr_Clear();
4312 return false;
4313 }
4314 return self->operator==(*obj);
4315 }
4316 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4317 wxGBSpan temp, *obj = &temp;
4318 if ( other == Py_None ) return true;
4319 if ( ! wxGBSpan_helper(other, &obj)) {
4320 PyErr_Clear();
4321 return true;
4322 }
4323 return self->operator!=(*obj);
4324 }
4325 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4326 self->SetRowspan(rowspan);
4327 self->SetColspan(colspan);
4328 }
4329 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4331 PyObject* tup = PyTuple_New(2);
4332 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4333 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4334 wxPyEndBlockThreads(blocked);
4335 return tup;
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(window, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4347 wxPyUserData* data = NULL;
4348 if ( userData ) {
4349 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4350 data = new wxPyUserData(userData);
4351 wxPyEndBlockThreads(blocked);
4352 }
4353 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4354 }
4355 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4356 wxPyUserData* data = NULL;
4357 if ( userData ) {
4358 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4359 data = new wxPyUserData(userData);
4360 wxPyEndBlockThreads(blocked);
4361 }
4362 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4363 }
4364 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4365 int row, col;
4366 self->GetEndPos(row, col);
4367 return wxGBPosition(row, col);
4368 }
4369 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4370
4371 wxPyUserData* data = NULL;
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4374 if ( userData && (info.window || info.sizer || info.gotSize) )
4375 data = new wxPyUserData(userData);
4376 if ( info.sizer )
4377 PyObject_SetAttrString(item,"thisown",Py_False);
4378 wxPyEndBlockThreads(blocked);
4379
4380 // Now call the real Add method if a valid item type was found
4381 if ( info.window )
4382 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4383 else if ( info.sizer )
4384 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4385 else if (info.gotSize)
4386 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4387 pos, span, flag, border, data);
4388 return NULL;
4389 }
4390
4391
4392 #ifdef __cplusplus
4393 extern "C" {
4394 #endif
4395 SWIGINTERN int EmptyString_set(PyObject *) {
4396 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4397 return 1;
4398 }
4399
4400
4401 SWIGINTERN PyObject *EmptyString_get(void) {
4402 PyObject *pyobj = 0;
4403
4404 {
4405 #if wxUSE_UNICODE
4406 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4407 #else
4408 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4409 #endif
4410 }
4411 return pyobj;
4412 }
4413
4414
4415 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4416 PyObject *resultobj = 0;
4417 wxObject *arg1 = (wxObject *) 0 ;
4418 wxString result;
4419 void *argp1 = 0 ;
4420 int res1 = 0 ;
4421 PyObject *swig_obj[1] ;
4422
4423 if (!args) SWIG_fail;
4424 swig_obj[0] = args;
4425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4426 if (!SWIG_IsOK(res1)) {
4427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4428 }
4429 arg1 = reinterpret_cast< wxObject * >(argp1);
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 result = wxObject_GetClassName(arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 #if wxUSE_UNICODE
4438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4439 #else
4440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4441 #endif
4442 }
4443 return resultobj;
4444 fail:
4445 return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4450 PyObject *resultobj = 0;
4451 wxObject *arg1 = (wxObject *) 0 ;
4452 void *argp1 = 0 ;
4453 int res1 = 0 ;
4454 PyObject *swig_obj[1] ;
4455
4456 if (!args) SWIG_fail;
4457 swig_obj[0] = args;
4458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4461 }
4462 arg1 = reinterpret_cast< wxObject * >(argp1);
4463 {
4464 PyThreadState* __tstate = wxPyBeginAllowThreads();
4465 wxObject_Destroy(arg1);
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 resultobj = SWIG_Py_Void();
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *obj;
4478 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4479 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4480 return SWIG_Py_Void();
4481 }
4482
4483 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4484 PyObject *resultobj = 0;
4485 wxSize *arg1 = (wxSize *) 0 ;
4486 int arg2 ;
4487 void *argp1 = 0 ;
4488 int res1 = 0 ;
4489 int val2 ;
4490 int ecode2 = 0 ;
4491 PyObject *swig_obj[2] ;
4492
4493 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4495 if (!SWIG_IsOK(res1)) {
4496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4497 }
4498 arg1 = reinterpret_cast< wxSize * >(argp1);
4499 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4500 if (!SWIG_IsOK(ecode2)) {
4501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4502 }
4503 arg2 = static_cast< int >(val2);
4504 if (arg1) (arg1)->x = arg2;
4505
4506 resultobj = SWIG_Py_Void();
4507 return resultobj;
4508 fail:
4509 return NULL;
4510 }
4511
4512
4513 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 PyObject *resultobj = 0;
4515 wxSize *arg1 = (wxSize *) 0 ;
4516 int result;
4517 void *argp1 = 0 ;
4518 int res1 = 0 ;
4519 PyObject *swig_obj[1] ;
4520
4521 if (!args) SWIG_fail;
4522 swig_obj[0] = args;
4523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4524 if (!SWIG_IsOK(res1)) {
4525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4526 }
4527 arg1 = reinterpret_cast< wxSize * >(argp1);
4528 result = (int) ((arg1)->x);
4529 resultobj = SWIG_From_int(static_cast< int >(result));
4530 return resultobj;
4531 fail:
4532 return NULL;
4533 }
4534
4535
4536 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4537 PyObject *resultobj = 0;
4538 wxSize *arg1 = (wxSize *) 0 ;
4539 int arg2 ;
4540 void *argp1 = 0 ;
4541 int res1 = 0 ;
4542 int val2 ;
4543 int ecode2 = 0 ;
4544 PyObject *swig_obj[2] ;
4545
4546 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4548 if (!SWIG_IsOK(res1)) {
4549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4550 }
4551 arg1 = reinterpret_cast< wxSize * >(argp1);
4552 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4553 if (!SWIG_IsOK(ecode2)) {
4554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4555 }
4556 arg2 = static_cast< int >(val2);
4557 if (arg1) (arg1)->y = arg2;
4558
4559 resultobj = SWIG_Py_Void();
4560 return resultobj;
4561 fail:
4562 return NULL;
4563 }
4564
4565
4566 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4567 PyObject *resultobj = 0;
4568 wxSize *arg1 = (wxSize *) 0 ;
4569 int result;
4570 void *argp1 = 0 ;
4571 int res1 = 0 ;
4572 PyObject *swig_obj[1] ;
4573
4574 if (!args) SWIG_fail;
4575 swig_obj[0] = args;
4576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 result = (int) ((arg1)->y);
4582 resultobj = SWIG_From_int(static_cast< int >(result));
4583 return resultobj;
4584 fail:
4585 return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4590 PyObject *resultobj = 0;
4591 int arg1 = (int) 0 ;
4592 int arg2 = (int) 0 ;
4593 wxSize *result = 0 ;
4594 int val1 ;
4595 int ecode1 = 0 ;
4596 int val2 ;
4597 int ecode2 = 0 ;
4598 PyObject * obj0 = 0 ;
4599 PyObject * obj1 = 0 ;
4600 char * kwnames[] = {
4601 (char *) "w",(char *) "h", NULL
4602 };
4603
4604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4605 if (obj0) {
4606 ecode1 = SWIG_AsVal_int(obj0, &val1);
4607 if (!SWIG_IsOK(ecode1)) {
4608 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4609 }
4610 arg1 = static_cast< int >(val1);
4611 }
4612 if (obj1) {
4613 ecode2 = SWIG_AsVal_int(obj1, &val2);
4614 if (!SWIG_IsOK(ecode2)) {
4615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4616 }
4617 arg2 = static_cast< int >(val2);
4618 }
4619 {
4620 PyThreadState* __tstate = wxPyBeginAllowThreads();
4621 result = (wxSize *)new wxSize(arg1,arg2);
4622 wxPyEndAllowThreads(__tstate);
4623 if (PyErr_Occurred()) SWIG_fail;
4624 }
4625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4633 PyObject *resultobj = 0;
4634 wxSize *arg1 = (wxSize *) 0 ;
4635 void *argp1 = 0 ;
4636 int res1 = 0 ;
4637 PyObject *swig_obj[1] ;
4638
4639 if (!args) SWIG_fail;
4640 swig_obj[0] = args;
4641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4644 }
4645 arg1 = reinterpret_cast< wxSize * >(argp1);
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 delete arg1;
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 resultobj = SWIG_Py_Void();
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 wxSize *arg1 = (wxSize *) 0 ;
4663 PyObject *arg2 = (PyObject *) 0 ;
4664 bool result;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char * kwnames[] = {
4670 (char *) "self",(char *) "other", NULL
4671 };
4672
4673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4677 }
4678 arg1 = reinterpret_cast< wxSize * >(argp1);
4679 arg2 = obj1;
4680 {
4681 result = (bool)wxSize___eq__(arg1,arg2);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxSize *arg1 = (wxSize *) 0 ;
4696 PyObject *arg2 = (PyObject *) 0 ;
4697 bool result;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 PyObject * obj0 = 0 ;
4701 PyObject * obj1 = 0 ;
4702 char * kwnames[] = {
4703 (char *) "self",(char *) "other", NULL
4704 };
4705
4706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4708 if (!SWIG_IsOK(res1)) {
4709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4710 }
4711 arg1 = reinterpret_cast< wxSize * >(argp1);
4712 arg2 = obj1;
4713 {
4714 result = (bool)wxSize___ne__(arg1,arg2);
4715 if (PyErr_Occurred()) SWIG_fail;
4716 }
4717 {
4718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4719 }
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 wxSize *arg2 = 0 ;
4730 wxSize result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 wxSize temp2 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "sz", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 {
4747 arg2 = &temp2;
4748 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4749 }
4750 {
4751 PyThreadState* __tstate = wxPyBeginAllowThreads();
4752 result = (arg1)->operator +((wxSize const &)*arg2);
4753 wxPyEndAllowThreads(__tstate);
4754 if (PyErr_Occurred()) SWIG_fail;
4755 }
4756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4757 return resultobj;
4758 fail:
4759 return NULL;
4760 }
4761
4762
4763 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4764 PyObject *resultobj = 0;
4765 wxSize *arg1 = (wxSize *) 0 ;
4766 wxSize *arg2 = 0 ;
4767 wxSize result;
4768 void *argp1 = 0 ;
4769 int res1 = 0 ;
4770 wxSize temp2 ;
4771 PyObject * obj0 = 0 ;
4772 PyObject * obj1 = 0 ;
4773 char * kwnames[] = {
4774 (char *) "self",(char *) "sz", NULL
4775 };
4776
4777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4779 if (!SWIG_IsOK(res1)) {
4780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4781 }
4782 arg1 = reinterpret_cast< wxSize * >(argp1);
4783 {
4784 arg2 = &temp2;
4785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4786 }
4787 {
4788 PyThreadState* __tstate = wxPyBeginAllowThreads();
4789 result = (arg1)->operator -((wxSize const &)*arg2);
4790 wxPyEndAllowThreads(__tstate);
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 wxSize *arg2 = 0 ;
4804 void *argp1 = 0 ;
4805 int res1 = 0 ;
4806 wxSize temp2 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "sz", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 {
4820 arg2 = &temp2;
4821 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4822 }
4823 {
4824 PyThreadState* __tstate = wxPyBeginAllowThreads();
4825 (arg1)->IncTo((wxSize const &)*arg2);
4826 wxPyEndAllowThreads(__tstate);
4827 if (PyErr_Occurred()) SWIG_fail;
4828 }
4829 resultobj = SWIG_Py_Void();
4830 return resultobj;
4831 fail:
4832 return NULL;
4833 }
4834
4835
4836 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4837 PyObject *resultobj = 0;
4838 wxSize *arg1 = (wxSize *) 0 ;
4839 wxSize *arg2 = 0 ;
4840 void *argp1 = 0 ;
4841 int res1 = 0 ;
4842 wxSize temp2 ;
4843 PyObject * obj0 = 0 ;
4844 PyObject * obj1 = 0 ;
4845 char * kwnames[] = {
4846 (char *) "self",(char *) "sz", NULL
4847 };
4848
4849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4851 if (!SWIG_IsOK(res1)) {
4852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4853 }
4854 arg1 = reinterpret_cast< wxSize * >(argp1);
4855 {
4856 arg2 = &temp2;
4857 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4858 }
4859 {
4860 PyThreadState* __tstate = wxPyBeginAllowThreads();
4861 (arg1)->DecTo((wxSize const &)*arg2);
4862 wxPyEndAllowThreads(__tstate);
4863 if (PyErr_Occurred()) SWIG_fail;
4864 }
4865 resultobj = SWIG_Py_Void();
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxSize *arg1 = (wxSize *) 0 ;
4875 int arg2 ;
4876 int arg3 ;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 int val2 ;
4880 int ecode2 = 0 ;
4881 int val3 ;
4882 int ecode3 = 0 ;
4883 PyObject * obj0 = 0 ;
4884 PyObject * obj1 = 0 ;
4885 PyObject * obj2 = 0 ;
4886 char * kwnames[] = {
4887 (char *) "self",(char *) "dx",(char *) "dy", NULL
4888 };
4889
4890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4892 if (!SWIG_IsOK(res1)) {
4893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4894 }
4895 arg1 = reinterpret_cast< wxSize * >(argp1);
4896 ecode2 = SWIG_AsVal_int(obj1, &val2);
4897 if (!SWIG_IsOK(ecode2)) {
4898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4899 }
4900 arg2 = static_cast< int >(val2);
4901 ecode3 = SWIG_AsVal_int(obj2, &val3);
4902 if (!SWIG_IsOK(ecode3)) {
4903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4904 }
4905 arg3 = static_cast< int >(val3);
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 (arg1)->IncBy(arg2,arg3);
4909 wxPyEndAllowThreads(__tstate);
4910 if (PyErr_Occurred()) SWIG_fail;
4911 }
4912 resultobj = SWIG_Py_Void();
4913 return resultobj;
4914 fail:
4915 return NULL;
4916 }
4917
4918
4919 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4920 PyObject *resultobj = 0;
4921 wxSize *arg1 = (wxSize *) 0 ;
4922 int arg2 ;
4923 int arg3 ;
4924 void *argp1 = 0 ;
4925 int res1 = 0 ;
4926 int val2 ;
4927 int ecode2 = 0 ;
4928 int val3 ;
4929 int ecode3 = 0 ;
4930 PyObject * obj0 = 0 ;
4931 PyObject * obj1 = 0 ;
4932 PyObject * obj2 = 0 ;
4933 char * kwnames[] = {
4934 (char *) "self",(char *) "dx",(char *) "dy", NULL
4935 };
4936
4937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4939 if (!SWIG_IsOK(res1)) {
4940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4941 }
4942 arg1 = reinterpret_cast< wxSize * >(argp1);
4943 ecode2 = SWIG_AsVal_int(obj1, &val2);
4944 if (!SWIG_IsOK(ecode2)) {
4945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
4946 }
4947 arg2 = static_cast< int >(val2);
4948 ecode3 = SWIG_AsVal_int(obj2, &val3);
4949 if (!SWIG_IsOK(ecode3)) {
4950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
4951 }
4952 arg3 = static_cast< int >(val3);
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 (arg1)->DecBy(arg2,arg3);
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 resultobj = SWIG_Py_Void();
4960 return resultobj;
4961 fail:
4962 return NULL;
4963 }
4964
4965
4966 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4967 PyObject *resultobj = 0;
4968 wxSize *arg1 = (wxSize *) 0 ;
4969 float arg2 ;
4970 float arg3 ;
4971 void *argp1 = 0 ;
4972 int res1 = 0 ;
4973 float val2 ;
4974 int ecode2 = 0 ;
4975 float val3 ;
4976 int ecode3 = 0 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 PyObject * obj2 = 0 ;
4980 char * kwnames[] = {
4981 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4982 };
4983
4984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4986 if (!SWIG_IsOK(res1)) {
4987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4988 }
4989 arg1 = reinterpret_cast< wxSize * >(argp1);
4990 ecode2 = SWIG_AsVal_float(obj1, &val2);
4991 if (!SWIG_IsOK(ecode2)) {
4992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4993 }
4994 arg2 = static_cast< float >(val2);
4995 ecode3 = SWIG_AsVal_float(obj2, &val3);
4996 if (!SWIG_IsOK(ecode3)) {
4997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4998 }
4999 arg3 = static_cast< float >(val3);
5000 {
5001 PyThreadState* __tstate = wxPyBeginAllowThreads();
5002 (arg1)->Scale(arg2,arg3);
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 resultobj = SWIG_Py_Void();
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj = 0;
5015 wxSize *arg1 = (wxSize *) 0 ;
5016 int arg2 ;
5017 int arg3 ;
5018 void *argp1 = 0 ;
5019 int res1 = 0 ;
5020 int val2 ;
5021 int ecode2 = 0 ;
5022 int val3 ;
5023 int ecode3 = 0 ;
5024 PyObject * obj0 = 0 ;
5025 PyObject * obj1 = 0 ;
5026 PyObject * obj2 = 0 ;
5027 char * kwnames[] = {
5028 (char *) "self",(char *) "w",(char *) "h", NULL
5029 };
5030
5031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5033 if (!SWIG_IsOK(res1)) {
5034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5035 }
5036 arg1 = reinterpret_cast< wxSize * >(argp1);
5037 ecode2 = SWIG_AsVal_int(obj1, &val2);
5038 if (!SWIG_IsOK(ecode2)) {
5039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5040 }
5041 arg2 = static_cast< int >(val2);
5042 ecode3 = SWIG_AsVal_int(obj2, &val3);
5043 if (!SWIG_IsOK(ecode3)) {
5044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5045 }
5046 arg3 = static_cast< int >(val3);
5047 {
5048 PyThreadState* __tstate = wxPyBeginAllowThreads();
5049 (arg1)->Set(arg2,arg3);
5050 wxPyEndAllowThreads(__tstate);
5051 if (PyErr_Occurred()) SWIG_fail;
5052 }
5053 resultobj = SWIG_Py_Void();
5054 return resultobj;
5055 fail:
5056 return NULL;
5057 }
5058
5059
5060 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5061 PyObject *resultobj = 0;
5062 wxSize *arg1 = (wxSize *) 0 ;
5063 int arg2 ;
5064 void *argp1 = 0 ;
5065 int res1 = 0 ;
5066 int val2 ;
5067 int ecode2 = 0 ;
5068 PyObject * obj0 = 0 ;
5069 PyObject * obj1 = 0 ;
5070 char * kwnames[] = {
5071 (char *) "self",(char *) "w", NULL
5072 };
5073
5074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5076 if (!SWIG_IsOK(res1)) {
5077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5078 }
5079 arg1 = reinterpret_cast< wxSize * >(argp1);
5080 ecode2 = SWIG_AsVal_int(obj1, &val2);
5081 if (!SWIG_IsOK(ecode2)) {
5082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5083 }
5084 arg2 = static_cast< int >(val2);
5085 {
5086 PyThreadState* __tstate = wxPyBeginAllowThreads();
5087 (arg1)->SetWidth(arg2);
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 resultobj = SWIG_Py_Void();
5092 return resultobj;
5093 fail:
5094 return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5099 PyObject *resultobj = 0;
5100 wxSize *arg1 = (wxSize *) 0 ;
5101 int arg2 ;
5102 void *argp1 = 0 ;
5103 int res1 = 0 ;
5104 int val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "h", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_int(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5121 }
5122 arg2 = static_cast< int >(val2);
5123 {
5124 PyThreadState* __tstate = wxPyBeginAllowThreads();
5125 (arg1)->SetHeight(arg2);
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 resultobj = SWIG_Py_Void();
5130 return resultobj;
5131 fail:
5132 return NULL;
5133 }
5134
5135
5136 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5137 PyObject *resultobj = 0;
5138 wxSize *arg1 = (wxSize *) 0 ;
5139 int result;
5140 void *argp1 = 0 ;
5141 int res1 = 0 ;
5142 PyObject *swig_obj[1] ;
5143
5144 if (!args) SWIG_fail;
5145 swig_obj[0] = args;
5146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5147 if (!SWIG_IsOK(res1)) {
5148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5149 }
5150 arg1 = reinterpret_cast< wxSize * >(argp1);
5151 {
5152 PyThreadState* __tstate = wxPyBeginAllowThreads();
5153 result = (int)((wxSize const *)arg1)->GetWidth();
5154 wxPyEndAllowThreads(__tstate);
5155 if (PyErr_Occurred()) SWIG_fail;
5156 }
5157 resultobj = SWIG_From_int(static_cast< int >(result));
5158 return resultobj;
5159 fail:
5160 return NULL;
5161 }
5162
5163
5164 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165 PyObject *resultobj = 0;
5166 wxSize *arg1 = (wxSize *) 0 ;
5167 int result;
5168 void *argp1 = 0 ;
5169 int res1 = 0 ;
5170 PyObject *swig_obj[1] ;
5171
5172 if (!args) SWIG_fail;
5173 swig_obj[0] = args;
5174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5175 if (!SWIG_IsOK(res1)) {
5176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5177 }
5178 arg1 = reinterpret_cast< wxSize * >(argp1);
5179 {
5180 PyThreadState* __tstate = wxPyBeginAllowThreads();
5181 result = (int)((wxSize const *)arg1)->GetHeight();
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 resultobj = SWIG_From_int(static_cast< int >(result));
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5193 PyObject *resultobj = 0;
5194 wxSize *arg1 = (wxSize *) 0 ;
5195 bool result;
5196 void *argp1 = 0 ;
5197 int res1 = 0 ;
5198 PyObject *swig_obj[1] ;
5199
5200 if (!args) SWIG_fail;
5201 swig_obj[0] = args;
5202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5203 if (!SWIG_IsOK(res1)) {
5204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5205 }
5206 arg1 = reinterpret_cast< wxSize * >(argp1);
5207 {
5208 PyThreadState* __tstate = wxPyBeginAllowThreads();
5209 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5210 wxPyEndAllowThreads(__tstate);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 {
5214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxSize *arg1 = (wxSize *) 0 ;
5225 wxSize *arg2 = 0 ;
5226 void *argp1 = 0 ;
5227 int res1 = 0 ;
5228 wxSize temp2 ;
5229 PyObject * obj0 = 0 ;
5230 PyObject * obj1 = 0 ;
5231 char * kwnames[] = {
5232 (char *) "self",(char *) "size", NULL
5233 };
5234
5235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5237 if (!SWIG_IsOK(res1)) {
5238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5239 }
5240 arg1 = reinterpret_cast< wxSize * >(argp1);
5241 {
5242 arg2 = &temp2;
5243 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5244 }
5245 {
5246 PyThreadState* __tstate = wxPyBeginAllowThreads();
5247 (arg1)->SetDefaults((wxSize const &)*arg2);
5248 wxPyEndAllowThreads(__tstate);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 resultobj = SWIG_Py_Void();
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5259 PyObject *resultobj = 0;
5260 wxSize *arg1 = (wxSize *) 0 ;
5261 PyObject *result = 0 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 PyObject *swig_obj[1] ;
5265
5266 if (!args) SWIG_fail;
5267 swig_obj[0] = args;
5268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5269 if (!SWIG_IsOK(res1)) {
5270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5271 }
5272 arg1 = reinterpret_cast< wxSize * >(argp1);
5273 {
5274 PyThreadState* __tstate = wxPyBeginAllowThreads();
5275 result = (PyObject *)wxSize_Get(arg1);
5276 wxPyEndAllowThreads(__tstate);
5277 if (PyErr_Occurred()) SWIG_fail;
5278 }
5279 resultobj = result;
5280 return resultobj;
5281 fail:
5282 return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287 PyObject *obj;
5288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5289 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5290 return SWIG_Py_Void();
5291 }
5292
5293 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5294 return SWIG_Python_InitShadowInstance(args);
5295 }
5296
5297 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5300 double arg2 ;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 double val2 ;
5304 int ecode2 = 0 ;
5305 PyObject *swig_obj[2] ;
5306
5307 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5309 if (!SWIG_IsOK(res1)) {
5310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5311 }
5312 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5313 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5314 if (!SWIG_IsOK(ecode2)) {
5315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5316 }
5317 arg2 = static_cast< double >(val2);
5318 if (arg1) (arg1)->x = arg2;
5319
5320 resultobj = SWIG_Py_Void();
5321 return resultobj;
5322 fail:
5323 return NULL;
5324 }
5325
5326
5327 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5328 PyObject *resultobj = 0;
5329 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5330 double result;
5331 void *argp1 = 0 ;
5332 int res1 = 0 ;
5333 PyObject *swig_obj[1] ;
5334
5335 if (!args) SWIG_fail;
5336 swig_obj[0] = args;
5337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5338 if (!SWIG_IsOK(res1)) {
5339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5340 }
5341 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5342 result = (double) ((arg1)->x);
5343 resultobj = SWIG_From_double(static_cast< double >(result));
5344 return resultobj;
5345 fail:
5346 return NULL;
5347 }
5348
5349
5350 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5351 PyObject *resultobj = 0;
5352 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5353 double arg2 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 double val2 ;
5357 int ecode2 = 0 ;
5358 PyObject *swig_obj[2] ;
5359
5360 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5362 if (!SWIG_IsOK(res1)) {
5363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5364 }
5365 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5366 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5367 if (!SWIG_IsOK(ecode2)) {
5368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5369 }
5370 arg2 = static_cast< double >(val2);
5371 if (arg1) (arg1)->y = arg2;
5372
5373 resultobj = SWIG_Py_Void();
5374 return resultobj;
5375 fail:
5376 return NULL;
5377 }
5378
5379
5380 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5381 PyObject *resultobj = 0;
5382 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5383 double result;
5384 void *argp1 = 0 ;
5385 int res1 = 0 ;
5386 PyObject *swig_obj[1] ;
5387
5388 if (!args) SWIG_fail;
5389 swig_obj[0] = args;
5390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5391 if (!SWIG_IsOK(res1)) {
5392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5393 }
5394 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5395 result = (double) ((arg1)->y);
5396 resultobj = SWIG_From_double(static_cast< double >(result));
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj = 0;
5405 double arg1 = (double) 0.0 ;
5406 double arg2 = (double) 0.0 ;
5407 wxRealPoint *result = 0 ;
5408 double val1 ;
5409 int ecode1 = 0 ;
5410 double val2 ;
5411 int ecode2 = 0 ;
5412 PyObject * obj0 = 0 ;
5413 PyObject * obj1 = 0 ;
5414 char * kwnames[] = {
5415 (char *) "x",(char *) "y", NULL
5416 };
5417
5418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5419 if (obj0) {
5420 ecode1 = SWIG_AsVal_double(obj0, &val1);
5421 if (!SWIG_IsOK(ecode1)) {
5422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5423 }
5424 arg1 = static_cast< double >(val1);
5425 }
5426 if (obj1) {
5427 ecode2 = SWIG_AsVal_double(obj1, &val2);
5428 if (!SWIG_IsOK(ecode2)) {
5429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5430 }
5431 arg2 = static_cast< double >(val2);
5432 }
5433 {
5434 PyThreadState* __tstate = wxPyBeginAllowThreads();
5435 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5436 wxPyEndAllowThreads(__tstate);
5437 if (PyErr_Occurred()) SWIG_fail;
5438 }
5439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5440 return resultobj;
5441 fail:
5442 return NULL;
5443 }
5444
5445
5446 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 PyObject *swig_obj[1] ;
5452
5453 if (!args) SWIG_fail;
5454 swig_obj[0] = args;
5455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5456 if (!SWIG_IsOK(res1)) {
5457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5458 }
5459 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5460 {
5461 PyThreadState* __tstate = wxPyBeginAllowThreads();
5462 delete arg1;
5463
5464 wxPyEndAllowThreads(__tstate);
5465 if (PyErr_Occurred()) SWIG_fail;
5466 }
5467 resultobj = SWIG_Py_Void();
5468 return resultobj;
5469 fail:
5470 return NULL;
5471 }
5472
5473
5474 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5475 PyObject *resultobj = 0;
5476 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5477 PyObject *arg2 = (PyObject *) 0 ;
5478 bool result;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject * obj0 = 0 ;
5482 PyObject * obj1 = 0 ;
5483 char * kwnames[] = {
5484 (char *) "self",(char *) "other", NULL
5485 };
5486
5487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5489 if (!SWIG_IsOK(res1)) {
5490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5491 }
5492 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5493 arg2 = obj1;
5494 {
5495 result = (bool)wxRealPoint___eq__(arg1,arg2);
5496 if (PyErr_Occurred()) SWIG_fail;
5497 }
5498 {
5499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5500 }
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj = 0;
5509 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5510 PyObject *arg2 = (PyObject *) 0 ;
5511 bool result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "other", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 arg2 = obj1;
5527 {
5528 result = (bool)wxRealPoint___ne__(arg1,arg2);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj = 0;
5542 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5543 wxRealPoint *arg2 = 0 ;
5544 wxRealPoint result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 wxRealPoint temp2 ;
5548 PyObject * obj0 = 0 ;
5549 PyObject * obj1 = 0 ;
5550 char * kwnames[] = {
5551 (char *) "self",(char *) "pt", NULL
5552 };
5553
5554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 arg2 = &temp2;
5562 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5563 }
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj = 0;
5579 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5580 wxRealPoint *arg2 = 0 ;
5581 wxRealPoint result;
5582 void *argp1 = 0 ;
5583 int res1 = 0 ;
5584 wxRealPoint temp2 ;
5585 PyObject * obj0 = 0 ;
5586 PyObject * obj1 = 0 ;
5587 char * kwnames[] = {
5588 (char *) "self",(char *) "pt", NULL
5589 };
5590
5591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5593 if (!SWIG_IsOK(res1)) {
5594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5595 }
5596 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5597 {
5598 arg2 = &temp2;
5599 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5600 }
5601 {
5602 PyThreadState* __tstate = wxPyBeginAllowThreads();
5603 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5604 wxPyEndAllowThreads(__tstate);
5605 if (PyErr_Occurred()) SWIG_fail;
5606 }
5607 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj = 0;
5616 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5617 double arg2 ;
5618 double arg3 ;
5619 void *argp1 = 0 ;
5620 int res1 = 0 ;
5621 double val2 ;
5622 int ecode2 = 0 ;
5623 double val3 ;
5624 int ecode3 = 0 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 PyObject * obj2 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "x",(char *) "y", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 ecode2 = SWIG_AsVal_double(obj1, &val2);
5639 if (!SWIG_IsOK(ecode2)) {
5640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5641 }
5642 arg2 = static_cast< double >(val2);
5643 ecode3 = SWIG_AsVal_double(obj2, &val3);
5644 if (!SWIG_IsOK(ecode3)) {
5645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5646 }
5647 arg3 = static_cast< double >(val3);
5648 {
5649 PyThreadState* __tstate = wxPyBeginAllowThreads();
5650 wxRealPoint_Set(arg1,arg2,arg3);
5651 wxPyEndAllowThreads(__tstate);
5652 if (PyErr_Occurred()) SWIG_fail;
5653 }
5654 resultobj = SWIG_Py_Void();
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5662 PyObject *resultobj = 0;
5663 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5664 PyObject *result = 0 ;
5665 void *argp1 = 0 ;
5666 int res1 = 0 ;
5667 PyObject *swig_obj[1] ;
5668
5669 if (!args) SWIG_fail;
5670 swig_obj[0] = args;
5671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5672 if (!SWIG_IsOK(res1)) {
5673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5674 }
5675 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5676 {
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 result = (PyObject *)wxRealPoint_Get(arg1);
5679 wxPyEndAllowThreads(__tstate);
5680 if (PyErr_Occurred()) SWIG_fail;
5681 }
5682 resultobj = result;
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5690 PyObject *obj;
5691 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5692 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5693 return SWIG_Py_Void();
5694 }
5695
5696 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697 return SWIG_Python_InitShadowInstance(args);
5698 }
5699
5700 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5701 PyObject *resultobj = 0;
5702 wxPoint *arg1 = (wxPoint *) 0 ;
5703 int arg2 ;
5704 void *argp1 = 0 ;
5705 int res1 = 0 ;
5706 int val2 ;
5707 int ecode2 = 0 ;
5708 PyObject *swig_obj[2] ;
5709
5710 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5712 if (!SWIG_IsOK(res1)) {
5713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5714 }
5715 arg1 = reinterpret_cast< wxPoint * >(argp1);
5716 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5717 if (!SWIG_IsOK(ecode2)) {
5718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5719 }
5720 arg2 = static_cast< int >(val2);
5721 if (arg1) (arg1)->x = arg2;
5722
5723 resultobj = SWIG_Py_Void();
5724 return resultobj;
5725 fail:
5726 return NULL;
5727 }
5728
5729
5730 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5731 PyObject *resultobj = 0;
5732 wxPoint *arg1 = (wxPoint *) 0 ;
5733 int result;
5734 void *argp1 = 0 ;
5735 int res1 = 0 ;
5736 PyObject *swig_obj[1] ;
5737
5738 if (!args) SWIG_fail;
5739 swig_obj[0] = args;
5740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5741 if (!SWIG_IsOK(res1)) {
5742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5743 }
5744 arg1 = reinterpret_cast< wxPoint * >(argp1);
5745 result = (int) ((arg1)->x);
5746 resultobj = SWIG_From_int(static_cast< int >(result));
5747 return resultobj;
5748 fail:
5749 return NULL;
5750 }
5751
5752
5753 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5754 PyObject *resultobj = 0;
5755 wxPoint *arg1 = (wxPoint *) 0 ;
5756 int arg2 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 int val2 ;
5760 int ecode2 = 0 ;
5761 PyObject *swig_obj[2] ;
5762
5763 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5770 if (!SWIG_IsOK(ecode2)) {
5771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5772 }
5773 arg2 = static_cast< int >(val2);
5774 if (arg1) (arg1)->y = arg2;
5775
5776 resultobj = SWIG_Py_Void();
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5784 PyObject *resultobj = 0;
5785 wxPoint *arg1 = (wxPoint *) 0 ;
5786 int result;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject *swig_obj[1] ;
5790
5791 if (!args) SWIG_fail;
5792 swig_obj[0] = args;
5793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5794 if (!SWIG_IsOK(res1)) {
5795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5796 }
5797 arg1 = reinterpret_cast< wxPoint * >(argp1);
5798 result = (int) ((arg1)->y);
5799 resultobj = SWIG_From_int(static_cast< int >(result));
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj = 0;
5808 int arg1 = (int) 0 ;
5809 int arg2 = (int) 0 ;
5810 wxPoint *result = 0 ;
5811 int val1 ;
5812 int ecode1 = 0 ;
5813 int val2 ;
5814 int ecode2 = 0 ;
5815 PyObject * obj0 = 0 ;
5816 PyObject * obj1 = 0 ;
5817 char * kwnames[] = {
5818 (char *) "x",(char *) "y", NULL
5819 };
5820
5821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5822 if (obj0) {
5823 ecode1 = SWIG_AsVal_int(obj0, &val1);
5824 if (!SWIG_IsOK(ecode1)) {
5825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5826 }
5827 arg1 = static_cast< int >(val1);
5828 }
5829 if (obj1) {
5830 ecode2 = SWIG_AsVal_int(obj1, &val2);
5831 if (!SWIG_IsOK(ecode2)) {
5832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5833 }
5834 arg2 = static_cast< int >(val2);
5835 }
5836 {
5837 PyThreadState* __tstate = wxPyBeginAllowThreads();
5838 result = (wxPoint *)new wxPoint(arg1,arg2);
5839 wxPyEndAllowThreads(__tstate);
5840 if (PyErr_Occurred()) SWIG_fail;
5841 }
5842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5843 return resultobj;
5844 fail:
5845 return NULL;
5846 }
5847
5848
5849 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5850 PyObject *resultobj = 0;
5851 wxPoint *arg1 = (wxPoint *) 0 ;
5852 void *argp1 = 0 ;
5853 int res1 = 0 ;
5854 PyObject *swig_obj[1] ;
5855
5856 if (!args) SWIG_fail;
5857 swig_obj[0] = args;
5858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5859 if (!SWIG_IsOK(res1)) {
5860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5861 }
5862 arg1 = reinterpret_cast< wxPoint * >(argp1);
5863 {
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 delete arg1;
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 resultobj = SWIG_Py_Void();
5871 return resultobj;
5872 fail:
5873 return NULL;
5874 }
5875
5876
5877 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5878 PyObject *resultobj = 0;
5879 wxPoint *arg1 = (wxPoint *) 0 ;
5880 PyObject *arg2 = (PyObject *) 0 ;
5881 bool result;
5882 void *argp1 = 0 ;
5883 int res1 = 0 ;
5884 PyObject * obj0 = 0 ;
5885 PyObject * obj1 = 0 ;
5886 char * kwnames[] = {
5887 (char *) "self",(char *) "other", NULL
5888 };
5889
5890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 arg2 = obj1;
5897 {
5898 result = (bool)wxPoint___eq__(arg1,arg2);
5899 if (PyErr_Occurred()) SWIG_fail;
5900 }
5901 {
5902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5903 }
5904 return resultobj;
5905 fail:
5906 return NULL;
5907 }
5908
5909
5910 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5911 PyObject *resultobj = 0;
5912 wxPoint *arg1 = (wxPoint *) 0 ;
5913 PyObject *arg2 = (PyObject *) 0 ;
5914 bool result;
5915 void *argp1 = 0 ;
5916 int res1 = 0 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char * kwnames[] = {
5920 (char *) "self",(char *) "other", NULL
5921 };
5922
5923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5925 if (!SWIG_IsOK(res1)) {
5926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5927 }
5928 arg1 = reinterpret_cast< wxPoint * >(argp1);
5929 arg2 = obj1;
5930 {
5931 result = (bool)wxPoint___ne__(arg1,arg2);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5936 }
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 wxPoint *arg1 = (wxPoint *) 0 ;
5946 wxPoint *arg2 = 0 ;
5947 wxPoint result;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 wxPoint temp2 ;
5951 PyObject * obj0 = 0 ;
5952 PyObject * obj1 = 0 ;
5953 char * kwnames[] = {
5954 (char *) "self",(char *) "pt", NULL
5955 };
5956
5957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5959 if (!SWIG_IsOK(res1)) {
5960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5961 }
5962 arg1 = reinterpret_cast< wxPoint * >(argp1);
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (arg1)->operator +((wxPoint const &)*arg2);
5970 wxPyEndAllowThreads(__tstate);
5971 if (PyErr_Occurred()) SWIG_fail;
5972 }
5973 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5974 return resultobj;
5975 fail:
5976 return NULL;
5977 }
5978
5979
5980 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5981 PyObject *resultobj = 0;
5982 wxPoint *arg1 = (wxPoint *) 0 ;
5983 wxPoint *arg2 = 0 ;
5984 wxPoint result;
5985 void *argp1 = 0 ;
5986 int res1 = 0 ;
5987 wxPoint temp2 ;
5988 PyObject * obj0 = 0 ;
5989 PyObject * obj1 = 0 ;
5990 char * kwnames[] = {
5991 (char *) "self",(char *) "pt", NULL
5992 };
5993
5994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5996 if (!SWIG_IsOK(res1)) {
5997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5998 }
5999 arg1 = reinterpret_cast< wxPoint * >(argp1);
6000 {
6001 arg2 = &temp2;
6002 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6003 }
6004 {
6005 PyThreadState* __tstate = wxPyBeginAllowThreads();
6006 result = (arg1)->operator -((wxPoint const &)*arg2);
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6011 return resultobj;
6012 fail:
6013 return NULL;
6014 }
6015
6016
6017 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6018 PyObject *resultobj = 0;
6019 wxPoint *arg1 = (wxPoint *) 0 ;
6020 wxPoint *arg2 = 0 ;
6021 wxPoint *result = 0 ;
6022 void *argp1 = 0 ;
6023 int res1 = 0 ;
6024 wxPoint temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char * kwnames[] = {
6028 (char *) "self",(char *) "pt", NULL
6029 };
6030
6031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6033 if (!SWIG_IsOK(res1)) {
6034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6035 }
6036 arg1 = reinterpret_cast< wxPoint * >(argp1);
6037 {
6038 arg2 = &temp2;
6039 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6040 }
6041 {
6042 PyThreadState* __tstate = wxPyBeginAllowThreads();
6043 {
6044 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6045 result = (wxPoint *) &_result_ref;
6046 }
6047 wxPyEndAllowThreads(__tstate);
6048 if (PyErr_Occurred()) SWIG_fail;
6049 }
6050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6051 return resultobj;
6052 fail:
6053 return NULL;
6054 }
6055
6056
6057 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6058 PyObject *resultobj = 0;
6059 wxPoint *arg1 = (wxPoint *) 0 ;
6060 wxPoint *arg2 = 0 ;
6061 wxPoint *result = 0 ;
6062 void *argp1 = 0 ;
6063 int res1 = 0 ;
6064 wxPoint temp2 ;
6065 PyObject * obj0 = 0 ;
6066 PyObject * obj1 = 0 ;
6067 char * kwnames[] = {
6068 (char *) "self",(char *) "pt", NULL
6069 };
6070
6071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6073 if (!SWIG_IsOK(res1)) {
6074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6075 }
6076 arg1 = reinterpret_cast< wxPoint * >(argp1);
6077 {
6078 arg2 = &temp2;
6079 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6080 }
6081 {
6082 PyThreadState* __tstate = wxPyBeginAllowThreads();
6083 {
6084 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6085 result = (wxPoint *) &_result_ref;
6086 }
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6098 PyObject *resultobj = 0;
6099 wxPoint *arg1 = (wxPoint *) 0 ;
6100 long arg2 ;
6101 long arg3 ;
6102 void *argp1 = 0 ;
6103 int res1 = 0 ;
6104 long val2 ;
6105 int ecode2 = 0 ;
6106 long val3 ;
6107 int ecode3 = 0 ;
6108 PyObject * obj0 = 0 ;
6109 PyObject * obj1 = 0 ;
6110 PyObject * obj2 = 0 ;
6111 char * kwnames[] = {
6112 (char *) "self",(char *) "x",(char *) "y", NULL
6113 };
6114
6115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6117 if (!SWIG_IsOK(res1)) {
6118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6119 }
6120 arg1 = reinterpret_cast< wxPoint * >(argp1);
6121 ecode2 = SWIG_AsVal_long(obj1, &val2);
6122 if (!SWIG_IsOK(ecode2)) {
6123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6124 }
6125 arg2 = static_cast< long >(val2);
6126 ecode3 = SWIG_AsVal_long(obj2, &val3);
6127 if (!SWIG_IsOK(ecode3)) {
6128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6129 }
6130 arg3 = static_cast< long >(val3);
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 wxPoint_Set(arg1,arg2,arg3);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 resultobj = SWIG_Py_Void();
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6145 PyObject *resultobj = 0;
6146 wxPoint *arg1 = (wxPoint *) 0 ;
6147 PyObject *result = 0 ;
6148 void *argp1 = 0 ;
6149 int res1 = 0 ;
6150 PyObject *swig_obj[1] ;
6151
6152 if (!args) SWIG_fail;
6153 swig_obj[0] = args;
6154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6155 if (!SWIG_IsOK(res1)) {
6156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6157 }
6158 arg1 = reinterpret_cast< wxPoint * >(argp1);
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (PyObject *)wxPoint_Get(arg1);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = result;
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6173 PyObject *obj;
6174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6175 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6176 return SWIG_Py_Void();
6177 }
6178
6179 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 return SWIG_Python_InitShadowInstance(args);
6181 }
6182
6183 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 int arg1 = (int) 0 ;
6186 int arg2 = (int) 0 ;
6187 int arg3 = (int) 0 ;
6188 int arg4 = (int) 0 ;
6189 wxRect *result = 0 ;
6190 int val1 ;
6191 int ecode1 = 0 ;
6192 int val2 ;
6193 int ecode2 = 0 ;
6194 int val3 ;
6195 int ecode3 = 0 ;
6196 int val4 ;
6197 int ecode4 = 0 ;
6198 PyObject * obj0 = 0 ;
6199 PyObject * obj1 = 0 ;
6200 PyObject * obj2 = 0 ;
6201 PyObject * obj3 = 0 ;
6202 char * kwnames[] = {
6203 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6204 };
6205
6206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6207 if (obj0) {
6208 ecode1 = SWIG_AsVal_int(obj0, &val1);
6209 if (!SWIG_IsOK(ecode1)) {
6210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6211 }
6212 arg1 = static_cast< int >(val1);
6213 }
6214 if (obj1) {
6215 ecode2 = SWIG_AsVal_int(obj1, &val2);
6216 if (!SWIG_IsOK(ecode2)) {
6217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6218 }
6219 arg2 = static_cast< int >(val2);
6220 }
6221 if (obj2) {
6222 ecode3 = SWIG_AsVal_int(obj2, &val3);
6223 if (!SWIG_IsOK(ecode3)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6225 }
6226 arg3 = static_cast< int >(val3);
6227 }
6228 if (obj3) {
6229 ecode4 = SWIG_AsVal_int(obj3, &val4);
6230 if (!SWIG_IsOK(ecode4)) {
6231 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6232 }
6233 arg4 = static_cast< int >(val4);
6234 }
6235 {
6236 PyThreadState* __tstate = wxPyBeginAllowThreads();
6237 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6238 wxPyEndAllowThreads(__tstate);
6239 if (PyErr_Occurred()) SWIG_fail;
6240 }
6241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6242 return resultobj;
6243 fail:
6244 return NULL;
6245 }
6246
6247
6248 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6249 PyObject *resultobj = 0;
6250 wxPoint *arg1 = 0 ;
6251 wxPoint *arg2 = 0 ;
6252 wxRect *result = 0 ;
6253 wxPoint temp1 ;
6254 wxPoint temp2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char * kwnames[] = {
6258 (char *) "topLeft",(char *) "bottomRight", NULL
6259 };
6260
6261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6262 {
6263 arg1 = &temp1;
6264 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6265 }
6266 {
6267 arg2 = &temp2;
6268 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6269 }
6270 {
6271 PyThreadState* __tstate = wxPyBeginAllowThreads();
6272 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6273 wxPyEndAllowThreads(__tstate);
6274 if (PyErr_Occurred()) SWIG_fail;
6275 }
6276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6277 return resultobj;
6278 fail:
6279 return NULL;
6280 }
6281
6282
6283 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6284 PyObject *resultobj = 0;
6285 wxPoint *arg1 = 0 ;
6286 wxSize *arg2 = 0 ;
6287 wxRect *result = 0 ;
6288 wxPoint temp1 ;
6289 wxSize temp2 ;
6290 PyObject * obj0 = 0 ;
6291 PyObject * obj1 = 0 ;
6292 char * kwnames[] = {
6293 (char *) "pos",(char *) "size", NULL
6294 };
6295
6296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6297 {
6298 arg1 = &temp1;
6299 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6300 }
6301 {
6302 arg2 = &temp2;
6303 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6304 }
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxSize *arg1 = 0 ;
6321 wxRect *result = 0 ;
6322 wxSize temp1 ;
6323 PyObject * obj0 = 0 ;
6324 char * kwnames[] = {
6325 (char *) "size", NULL
6326 };
6327
6328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6329 {
6330 arg1 = &temp1;
6331 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6332 }
6333 {
6334 PyThreadState* __tstate = wxPyBeginAllowThreads();
6335 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6336 wxPyEndAllowThreads(__tstate);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 delete arg1;
6363
6364 wxPyEndAllowThreads(__tstate);
6365 if (PyErr_Occurred()) SWIG_fail;
6366 }
6367 resultobj = SWIG_Py_Void();
6368 return resultobj;
6369 fail:
6370 return NULL;
6371 }
6372
6373
6374 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6375 PyObject *resultobj = 0;
6376 wxRect *arg1 = (wxRect *) 0 ;
6377 int result;
6378 void *argp1 = 0 ;
6379 int res1 = 0 ;
6380 PyObject *swig_obj[1] ;
6381
6382 if (!args) SWIG_fail;
6383 swig_obj[0] = args;
6384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6385 if (!SWIG_IsOK(res1)) {
6386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6387 }
6388 arg1 = reinterpret_cast< wxRect * >(argp1);
6389 {
6390 PyThreadState* __tstate = wxPyBeginAllowThreads();
6391 result = (int)((wxRect const *)arg1)->GetX();
6392 wxPyEndAllowThreads(__tstate);
6393 if (PyErr_Occurred()) SWIG_fail;
6394 }
6395 resultobj = SWIG_From_int(static_cast< int >(result));
6396 return resultobj;
6397 fail:
6398 return NULL;
6399 }
6400
6401
6402 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6403 PyObject *resultobj = 0;
6404 wxRect *arg1 = (wxRect *) 0 ;
6405 int arg2 ;
6406 void *argp1 = 0 ;
6407 int res1 = 0 ;
6408 int val2 ;
6409 int ecode2 = 0 ;
6410 PyObject * obj0 = 0 ;
6411 PyObject * obj1 = 0 ;
6412 char * kwnames[] = {
6413 (char *) "self",(char *) "x", NULL
6414 };
6415
6416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6418 if (!SWIG_IsOK(res1)) {
6419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6420 }
6421 arg1 = reinterpret_cast< wxRect * >(argp1);
6422 ecode2 = SWIG_AsVal_int(obj1, &val2);
6423 if (!SWIG_IsOK(ecode2)) {
6424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6425 }
6426 arg2 = static_cast< int >(val2);
6427 {
6428 PyThreadState* __tstate = wxPyBeginAllowThreads();
6429 (arg1)->SetX(arg2);
6430 wxPyEndAllowThreads(__tstate);
6431 if (PyErr_Occurred()) SWIG_fail;
6432 }
6433 resultobj = SWIG_Py_Void();
6434 return resultobj;
6435 fail:
6436 return NULL;
6437 }
6438
6439
6440 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441 PyObject *resultobj = 0;
6442 wxRect *arg1 = (wxRect *) 0 ;
6443 int result;
6444 void *argp1 = 0 ;
6445 int res1 = 0 ;
6446 PyObject *swig_obj[1] ;
6447
6448 if (!args) SWIG_fail;
6449 swig_obj[0] = args;
6450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6451 if (!SWIG_IsOK(res1)) {
6452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6453 }
6454 arg1 = reinterpret_cast< wxRect * >(argp1);
6455 {
6456 PyThreadState* __tstate = wxPyBeginAllowThreads();
6457 result = (int)(arg1)->GetY();
6458 wxPyEndAllowThreads(__tstate);
6459 if (PyErr_Occurred()) SWIG_fail;
6460 }
6461 resultobj = SWIG_From_int(static_cast< int >(result));
6462 return resultobj;
6463 fail:
6464 return NULL;
6465 }
6466
6467
6468 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj = 0;
6470 wxRect *arg1 = (wxRect *) 0 ;
6471 int arg2 ;
6472 void *argp1 = 0 ;
6473 int res1 = 0 ;
6474 int val2 ;
6475 int ecode2 = 0 ;
6476 PyObject * obj0 = 0 ;
6477 PyObject * obj1 = 0 ;
6478 char * kwnames[] = {
6479 (char *) "self",(char *) "y", NULL
6480 };
6481
6482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6484 if (!SWIG_IsOK(res1)) {
6485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6486 }
6487 arg1 = reinterpret_cast< wxRect * >(argp1);
6488 ecode2 = SWIG_AsVal_int(obj1, &val2);
6489 if (!SWIG_IsOK(ecode2)) {
6490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6491 }
6492 arg2 = static_cast< int >(val2);
6493 {
6494 PyThreadState* __tstate = wxPyBeginAllowThreads();
6495 (arg1)->SetY(arg2);
6496 wxPyEndAllowThreads(__tstate);
6497 if (PyErr_Occurred()) SWIG_fail;
6498 }
6499 resultobj = SWIG_Py_Void();
6500 return resultobj;
6501 fail:
6502 return NULL;
6503 }
6504
6505
6506 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6507 PyObject *resultobj = 0;
6508 wxRect *arg1 = (wxRect *) 0 ;
6509 int result;
6510 void *argp1 = 0 ;
6511 int res1 = 0 ;
6512 PyObject *swig_obj[1] ;
6513
6514 if (!args) SWIG_fail;
6515 swig_obj[0] = args;
6516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6517 if (!SWIG_IsOK(res1)) {
6518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6519 }
6520 arg1 = reinterpret_cast< wxRect * >(argp1);
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (int)((wxRect const *)arg1)->GetWidth();
6524 wxPyEndAllowThreads(__tstate);
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 int arg2 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 int val2 ;
6541 int ecode2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "w", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 ecode2 = SWIG_AsVal_int(obj1, &val2);
6555 if (!SWIG_IsOK(ecode2)) {
6556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 PyThreadState* __tstate = wxPyBeginAllowThreads();
6561 (arg1)->SetWidth(arg2);
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_Py_Void();
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6573 PyObject *resultobj = 0;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 int result;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 PyObject *swig_obj[1] ;
6579
6580 if (!args) SWIG_fail;
6581 swig_obj[0] = args;
6582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6583 if (!SWIG_IsOK(res1)) {
6584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6585 }
6586 arg1 = reinterpret_cast< wxRect * >(argp1);
6587 {
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 result = (int)((wxRect const *)arg1)->GetHeight();
6590 wxPyEndAllowThreads(__tstate);
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 PyThreadState* __tstate = wxPyBeginAllowThreads();
6627 (arg1)->SetHeight(arg2);
6628 wxPyEndAllowThreads(__tstate);
6629 if (PyErr_Occurred()) SWIG_fail;
6630 }
6631 resultobj = SWIG_Py_Void();
6632 return resultobj;
6633 fail:
6634 return NULL;
6635 }
6636
6637
6638 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639 PyObject *resultobj = 0;
6640 wxRect *arg1 = (wxRect *) 0 ;
6641 wxPoint result;
6642 void *argp1 = 0 ;
6643 int res1 = 0 ;
6644 PyObject *swig_obj[1] ;
6645
6646 if (!args) SWIG_fail;
6647 swig_obj[0] = args;
6648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6649 if (!SWIG_IsOK(res1)) {
6650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6651 }
6652 arg1 = reinterpret_cast< wxRect * >(argp1);
6653 {
6654 PyThreadState* __tstate = wxPyBeginAllowThreads();
6655 result = ((wxRect const *)arg1)->GetPosition();
6656 wxPyEndAllowThreads(__tstate);
6657 if (PyErr_Occurred()) SWIG_fail;
6658 }
6659 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6660 return resultobj;
6661 fail:
6662 return NULL;
6663 }
6664
6665
6666 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6667 PyObject *resultobj = 0;
6668 wxRect *arg1 = (wxRect *) 0 ;
6669 wxPoint *arg2 = 0 ;
6670 void *argp1 = 0 ;
6671 int res1 = 0 ;
6672 wxPoint temp2 ;
6673 PyObject * obj0 = 0 ;
6674 PyObject * obj1 = 0 ;
6675 char * kwnames[] = {
6676 (char *) "self",(char *) "p", NULL
6677 };
6678
6679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 arg2 = &temp2;
6687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 (arg1)->SetPosition((wxPoint const &)*arg2);
6692 wxPyEndAllowThreads(__tstate);
6693 if (PyErr_Occurred()) SWIG_fail;
6694 }
6695 resultobj = SWIG_Py_Void();
6696 return resultobj;
6697 fail:
6698 return NULL;
6699 }
6700
6701
6702 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6703 PyObject *resultobj = 0;
6704 wxRect *arg1 = (wxRect *) 0 ;
6705 wxSize result;
6706 void *argp1 = 0 ;
6707 int res1 = 0 ;
6708 PyObject *swig_obj[1] ;
6709
6710 if (!args) SWIG_fail;
6711 swig_obj[0] = args;
6712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 {
6718 PyThreadState* __tstate = wxPyBeginAllowThreads();
6719 result = ((wxRect const *)arg1)->GetSize();
6720 wxPyEndAllowThreads(__tstate);
6721 if (PyErr_Occurred()) SWIG_fail;
6722 }
6723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6724 return resultobj;
6725 fail:
6726 return NULL;
6727 }
6728
6729
6730 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6731 PyObject *resultobj = 0;
6732 wxRect *arg1 = (wxRect *) 0 ;
6733 wxSize *arg2 = 0 ;
6734 void *argp1 = 0 ;
6735 int res1 = 0 ;
6736 wxSize temp2 ;
6737 PyObject * obj0 = 0 ;
6738 PyObject * obj1 = 0 ;
6739 char * kwnames[] = {
6740 (char *) "self",(char *) "s", NULL
6741 };
6742
6743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6745 if (!SWIG_IsOK(res1)) {
6746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6747 }
6748 arg1 = reinterpret_cast< wxRect * >(argp1);
6749 {
6750 arg2 = &temp2;
6751 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6752 }
6753 {
6754 PyThreadState* __tstate = wxPyBeginAllowThreads();
6755 (arg1)->SetSize((wxSize const &)*arg2);
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 resultobj = SWIG_Py_Void();
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6767 PyObject *resultobj = 0;
6768 wxRect *arg1 = (wxRect *) 0 ;
6769 bool result;
6770 void *argp1 = 0 ;
6771 int res1 = 0 ;
6772 PyObject *swig_obj[1] ;
6773
6774 if (!args) SWIG_fail;
6775 swig_obj[0] = args;
6776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6777 if (!SWIG_IsOK(res1)) {
6778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6779 }
6780 arg1 = reinterpret_cast< wxRect * >(argp1);
6781 {
6782 PyThreadState* __tstate = wxPyBeginAllowThreads();
6783 result = (bool)((wxRect const *)arg1)->IsEmpty();
6784 wxPyEndAllowThreads(__tstate);
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 {
6788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6789 }
6790 return resultobj;
6791 fail:
6792 return NULL;
6793 }
6794
6795
6796 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6797 PyObject *resultobj = 0;
6798 wxRect *arg1 = (wxRect *) 0 ;
6799 wxPoint result;
6800 void *argp1 = 0 ;
6801 int res1 = 0 ;
6802 PyObject *swig_obj[1] ;
6803
6804 if (!args) SWIG_fail;
6805 swig_obj[0] = args;
6806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6807 if (!SWIG_IsOK(res1)) {
6808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6809 }
6810 arg1 = reinterpret_cast< wxRect * >(argp1);
6811 {
6812 PyThreadState* __tstate = wxPyBeginAllowThreads();
6813 result = ((wxRect const *)arg1)->GetTopLeft();
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj = 0;
6826 wxRect *arg1 = (wxRect *) 0 ;
6827 wxPoint *arg2 = 0 ;
6828 void *argp1 = 0 ;
6829 int res1 = 0 ;
6830 wxPoint temp2 ;
6831 PyObject * obj0 = 0 ;
6832 PyObject * obj1 = 0 ;
6833 char * kwnames[] = {
6834 (char *) "self",(char *) "p", NULL
6835 };
6836
6837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 arg2 = &temp2;
6845 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6846 }
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 resultobj = SWIG_Py_Void();
6854 return resultobj;
6855 fail:
6856 return NULL;
6857 }
6858
6859
6860 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6861 PyObject *resultobj = 0;
6862 wxRect *arg1 = (wxRect *) 0 ;
6863 wxPoint result;
6864 void *argp1 = 0 ;
6865 int res1 = 0 ;
6866 PyObject *swig_obj[1] ;
6867
6868 if (!args) SWIG_fail;
6869 swig_obj[0] = args;
6870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6871 if (!SWIG_IsOK(res1)) {
6872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6873 }
6874 arg1 = reinterpret_cast< wxRect * >(argp1);
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = ((wxRect const *)arg1)->GetBottomRight();
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint *arg2 = 0 ;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 wxPoint temp2 ;
6895 PyObject * obj0 = 0 ;
6896 PyObject * obj1 = 0 ;
6897 char * kwnames[] = {
6898 (char *) "self",(char *) "p", NULL
6899 };
6900
6901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 arg2 = &temp2;
6909 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6910 }
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_Py_Void();
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 wxPoint result;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 PyObject *swig_obj[1] ;
6931
6932 if (!args) SWIG_fail;
6933 swig_obj[0] = args;
6934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6935 if (!SWIG_IsOK(res1)) {
6936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6937 }
6938 arg1 = reinterpret_cast< wxRect * >(argp1);
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = ((wxRect const *)arg1)->GetTopRight();
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6953 PyObject *resultobj = 0;
6954 wxRect *arg1 = (wxRect *) 0 ;
6955 wxPoint *arg2 = 0 ;
6956 void *argp1 = 0 ;
6957 int res1 = 0 ;
6958 wxPoint temp2 ;
6959 PyObject * obj0 = 0 ;
6960 PyObject * obj1 = 0 ;
6961 char * kwnames[] = {
6962 (char *) "self",(char *) "p", NULL
6963 };
6964
6965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6967 if (!SWIG_IsOK(res1)) {
6968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6969 }
6970 arg1 = reinterpret_cast< wxRect * >(argp1);
6971 {
6972 arg2 = &temp2;
6973 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6974 }
6975 {
6976 PyThreadState* __tstate = wxPyBeginAllowThreads();
6977 (arg1)->SetTopRight((wxPoint const &)*arg2);
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 resultobj = SWIG_Py_Void();
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6989 PyObject *resultobj = 0;
6990 wxRect *arg1 = (wxRect *) 0 ;
6991 wxPoint result;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 PyObject *swig_obj[1] ;
6995
6996 if (!args) SWIG_fail;
6997 swig_obj[0] = args;
6998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6999 if (!SWIG_IsOK(res1)) {
7000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7001 }
7002 arg1 = reinterpret_cast< wxRect * >(argp1);
7003 {
7004 PyThreadState* __tstate = wxPyBeginAllowThreads();
7005 result = ((wxRect const *)arg1)->GetBottomLeft();
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7010 return resultobj;
7011 fail:
7012 return NULL;
7013 }
7014
7015
7016 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7017 PyObject *resultobj = 0;
7018 wxRect *arg1 = (wxRect *) 0 ;
7019 wxPoint *arg2 = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 wxPoint temp2 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "p", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 {
7036 arg2 = &temp2;
7037 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7038 }
7039 {
7040 PyThreadState* __tstate = wxPyBeginAllowThreads();
7041 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7042 wxPyEndAllowThreads(__tstate);
7043 if (PyErr_Occurred()) SWIG_fail;
7044 }
7045 resultobj = SWIG_Py_Void();
7046 return resultobj;
7047 fail:
7048 return NULL;
7049 }
7050
7051
7052 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7053 PyObject *resultobj = 0;
7054 wxRect *arg1 = (wxRect *) 0 ;
7055 int result;
7056 void *argp1 = 0 ;
7057 int res1 = 0 ;
7058 PyObject *swig_obj[1] ;
7059
7060 if (!args) SWIG_fail;
7061 swig_obj[0] = args;
7062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7063 if (!SWIG_IsOK(res1)) {
7064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7065 }
7066 arg1 = reinterpret_cast< wxRect * >(argp1);
7067 {
7068 PyThreadState* __tstate = wxPyBeginAllowThreads();
7069 result = (int)((wxRect const *)arg1)->GetLeft();
7070 wxPyEndAllowThreads(__tstate);
7071 if (PyErr_Occurred()) SWIG_fail;
7072 }
7073 resultobj = SWIG_From_int(static_cast< int >(result));
7074 return resultobj;
7075 fail:
7076 return NULL;
7077 }
7078
7079
7080 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7081 PyObject *resultobj = 0;
7082 wxRect *arg1 = (wxRect *) 0 ;
7083 int result;
7084 void *argp1 = 0 ;
7085 int res1 = 0 ;
7086 PyObject *swig_obj[1] ;
7087
7088 if (!args) SWIG_fail;
7089 swig_obj[0] = args;
7090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7091 if (!SWIG_IsOK(res1)) {
7092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7093 }
7094 arg1 = reinterpret_cast< wxRect * >(argp1);
7095 {
7096 PyThreadState* __tstate = wxPyBeginAllowThreads();
7097 result = (int)((wxRect const *)arg1)->GetTop();
7098 wxPyEndAllowThreads(__tstate);
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_From_int(static_cast< int >(result));
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int result;
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_wxRect, 0 | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 {
7124 PyThreadState* __tstate = wxPyBeginAllowThreads();
7125 result = (int)((wxRect const *)arg1)->GetBottom();
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 resultobj = SWIG_From_int(static_cast< int >(result));
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7137 PyObject *resultobj = 0;
7138 wxRect *arg1 = (wxRect *) 0 ;
7139 int result;
7140 void *argp1 = 0 ;
7141 int res1 = 0 ;
7142 PyObject *swig_obj[1] ;
7143
7144 if (!args) SWIG_fail;
7145 swig_obj[0] = args;
7146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7147 if (!SWIG_IsOK(res1)) {
7148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7149 }
7150 arg1 = reinterpret_cast< wxRect * >(argp1);
7151 {
7152 PyThreadState* __tstate = wxPyBeginAllowThreads();
7153 result = (int)((wxRect const *)arg1)->GetRight();
7154 wxPyEndAllowThreads(__tstate);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_From_int(static_cast< int >(result));
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "left", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 (arg1)->SetLeft(arg2);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_Py_Void();
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 int arg2 ;
7206 void *argp1 = 0 ;
7207 int res1 = 0 ;
7208 int val2 ;
7209 int ecode2 = 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "right", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 ecode2 = SWIG_AsVal_int(obj1, &val2);
7223 if (!SWIG_IsOK(ecode2)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7225 }
7226 arg2 = static_cast< int >(val2);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->SetRight(arg2);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 int arg2 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 int val2 ;
7247 int ecode2 = 0 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char * kwnames[] = {
7251 (char *) "self",(char *) "top", NULL
7252 };
7253
7254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7256 if (!SWIG_IsOK(res1)) {
7257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7258 }
7259 arg1 = reinterpret_cast< wxRect * >(argp1);
7260 ecode2 = SWIG_AsVal_int(obj1, &val2);
7261 if (!SWIG_IsOK(ecode2)) {
7262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7263 }
7264 arg2 = static_cast< int >(val2);
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 (arg1)->SetTop(arg2);
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_Py_Void();
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj = 0;
7280 wxRect *arg1 = (wxRect *) 0 ;
7281 int arg2 ;
7282 void *argp1 = 0 ;
7283 int res1 = 0 ;
7284 int val2 ;
7285 int ecode2 = 0 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "bottom", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 ecode2 = SWIG_AsVal_int(obj1, &val2);
7299 if (!SWIG_IsOK(ecode2)) {
7300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7301 }
7302 arg2 = static_cast< int >(val2);
7303 {
7304 PyThreadState* __tstate = wxPyBeginAllowThreads();
7305 (arg1)->SetBottom(arg2);
7306 wxPyEndAllowThreads(__tstate);
7307 if (PyErr_Occurred()) SWIG_fail;
7308 }
7309 resultobj = SWIG_Py_Void();
7310 return resultobj;
7311 fail:
7312 return NULL;
7313 }
7314
7315
7316 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7317 PyObject *resultobj = 0;
7318 wxRect *arg1 = (wxRect *) 0 ;
7319 int arg2 ;
7320 int arg3 ;
7321 wxRect *result = 0 ;
7322 void *argp1 = 0 ;
7323 int res1 = 0 ;
7324 int val2 ;
7325 int ecode2 = 0 ;
7326 int val3 ;
7327 int ecode3 = 0 ;
7328 PyObject * obj0 = 0 ;
7329 PyObject * obj1 = 0 ;
7330 PyObject * obj2 = 0 ;
7331 char * kwnames[] = {
7332 (char *) "self",(char *) "dx",(char *) "dy", NULL
7333 };
7334
7335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7337 if (!SWIG_IsOK(res1)) {
7338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7339 }
7340 arg1 = reinterpret_cast< wxRect * >(argp1);
7341 ecode2 = SWIG_AsVal_int(obj1, &val2);
7342 if (!SWIG_IsOK(ecode2)) {
7343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7344 }
7345 arg2 = static_cast< int >(val2);
7346 ecode3 = SWIG_AsVal_int(obj2, &val3);
7347 if (!SWIG_IsOK(ecode3)) {
7348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7349 }
7350 arg3 = static_cast< int >(val3);
7351 {
7352 PyThreadState* __tstate = wxPyBeginAllowThreads();
7353 {
7354 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7355 result = (wxRect *) &_result_ref;
7356 }
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 int arg2 ;
7371 int arg3 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 int val2 ;
7376 int ecode2 = 0 ;
7377 int val3 ;
7378 int ecode3 = 0 ;
7379 PyObject * obj0 = 0 ;
7380 PyObject * obj1 = 0 ;
7381 PyObject * obj2 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "dx",(char *) "dy", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 ecode2 = SWIG_AsVal_int(obj1, &val2);
7393 if (!SWIG_IsOK(ecode2)) {
7394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7395 }
7396 arg2 = static_cast< int >(val2);
7397 ecode3 = SWIG_AsVal_int(obj2, &val3);
7398 if (!SWIG_IsOK(ecode3)) {
7399 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7400 }
7401 arg3 = static_cast< int >(val3);
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 {
7405 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7406 result = (wxRect *) &_result_ref;
7407 }
7408 wxPyEndAllowThreads(__tstate);
7409 if (PyErr_Occurred()) SWIG_fail;
7410 }
7411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7412 return resultobj;
7413 fail:
7414 return NULL;
7415 }
7416
7417
7418 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7419 PyObject *resultobj = 0;
7420 wxRect *arg1 = (wxRect *) 0 ;
7421 int arg2 ;
7422 int arg3 ;
7423 void *argp1 = 0 ;
7424 int res1 = 0 ;
7425 int val2 ;
7426 int ecode2 = 0 ;
7427 int val3 ;
7428 int ecode3 = 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 PyObject * obj2 = 0 ;
7432 char * kwnames[] = {
7433 (char *) "self",(char *) "dx",(char *) "dy", NULL
7434 };
7435
7436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7438 if (!SWIG_IsOK(res1)) {
7439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7440 }
7441 arg1 = reinterpret_cast< wxRect * >(argp1);
7442 ecode2 = SWIG_AsVal_int(obj1, &val2);
7443 if (!SWIG_IsOK(ecode2)) {
7444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7445 }
7446 arg2 = static_cast< int >(val2);
7447 ecode3 = SWIG_AsVal_int(obj2, &val3);
7448 if (!SWIG_IsOK(ecode3)) {
7449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7450 }
7451 arg3 = static_cast< int >(val3);
7452 {
7453 PyThreadState* __tstate = wxPyBeginAllowThreads();
7454 (arg1)->Offset(arg2,arg3);
7455 wxPyEndAllowThreads(__tstate);
7456 if (PyErr_Occurred()) SWIG_fail;
7457 }
7458 resultobj = SWIG_Py_Void();
7459 return resultobj;
7460 fail:
7461 return NULL;
7462 }
7463
7464
7465 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7466 PyObject *resultobj = 0;
7467 wxRect *arg1 = (wxRect *) 0 ;
7468 wxPoint *arg2 = 0 ;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 wxPoint temp2 ;
7472 PyObject * obj0 = 0 ;
7473 PyObject * obj1 = 0 ;
7474 char * kwnames[] = {
7475 (char *) "self",(char *) "pt", NULL
7476 };
7477
7478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7480 if (!SWIG_IsOK(res1)) {
7481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7482 }
7483 arg1 = reinterpret_cast< wxRect * >(argp1);
7484 {
7485 arg2 = &temp2;
7486 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7487 }
7488 {
7489 PyThreadState* __tstate = wxPyBeginAllowThreads();
7490 (arg1)->Offset((wxPoint const &)*arg2);
7491 wxPyEndAllowThreads(__tstate);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = SWIG_Py_Void();
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = 0;
7503 wxRect *arg1 = (wxRect *) 0 ;
7504 wxRect *arg2 = 0 ;
7505 wxRect result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 wxRect temp2 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "rect", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7519 }
7520 arg1 = reinterpret_cast< wxRect * >(argp1);
7521 {
7522 arg2 = &temp2;
7523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7524 }
7525 {
7526 PyThreadState* __tstate = wxPyBeginAllowThreads();
7527 result = (arg1)->Intersect((wxRect const &)*arg2);
7528 wxPyEndAllowThreads(__tstate);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect result;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 result = (arg1)->Union((wxRect const &)*arg2);
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj = 0;
7577 wxRect *arg1 = (wxRect *) 0 ;
7578 wxRect *arg2 = 0 ;
7579 wxRect result;
7580 void *argp1 = 0 ;
7581 int res1 = 0 ;
7582 wxRect temp2 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "rect", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 {
7596 arg2 = &temp2;
7597 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7598 }
7599 {
7600 PyThreadState* __tstate = wxPyBeginAllowThreads();
7601 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = 0;
7614 wxRect *arg1 = (wxRect *) 0 ;
7615 wxRect *arg2 = 0 ;
7616 wxRect *result = 0 ;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 wxRect temp2 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "rect", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 {
7633 arg2 = &temp2;
7634 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7635 }
7636 {
7637 PyThreadState* __tstate = wxPyBeginAllowThreads();
7638 {
7639 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7640 result = (wxRect *) &_result_ref;
7641 }
7642 wxPyEndAllowThreads(__tstate);
7643 if (PyErr_Occurred()) SWIG_fail;
7644 }
7645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7646 return resultobj;
7647 fail:
7648 return NULL;
7649 }
7650
7651
7652 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7653 PyObject *resultobj = 0;
7654 wxRect *arg1 = (wxRect *) 0 ;
7655 PyObject *arg2 = (PyObject *) 0 ;
7656 bool result;
7657 void *argp1 = 0 ;
7658 int res1 = 0 ;
7659 PyObject * obj0 = 0 ;
7660 PyObject * obj1 = 0 ;
7661 char * kwnames[] = {
7662 (char *) "self",(char *) "other", NULL
7663 };
7664
7665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 arg2 = obj1;
7672 {
7673 result = (bool)wxRect___eq__(arg1,arg2);
7674 if (PyErr_Occurred()) SWIG_fail;
7675 }
7676 {
7677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7678 }
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 PyObject *arg2 = (PyObject *) 0 ;
7689 bool result;
7690 void *argp1 = 0 ;
7691 int res1 = 0 ;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char * kwnames[] = {
7695 (char *) "self",(char *) "other", NULL
7696 };
7697
7698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 arg2 = obj1;
7705 {
7706 result = (bool)wxRect___ne__(arg1,arg2);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 int arg2 ;
7722 int arg3 ;
7723 bool result;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 int val2 ;
7727 int ecode2 = 0 ;
7728 int val3 ;
7729 int ecode3 = 0 ;
7730 PyObject * obj0 = 0 ;
7731 PyObject * obj1 = 0 ;
7732 PyObject * obj2 = 0 ;
7733 char * kwnames[] = {
7734 (char *) "self",(char *) "x",(char *) "y", NULL
7735 };
7736
7737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7739 if (!SWIG_IsOK(res1)) {
7740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 ecode2 = SWIG_AsVal_int(obj1, &val2);
7744 if (!SWIG_IsOK(ecode2)) {
7745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7746 }
7747 arg2 = static_cast< int >(val2);
7748 ecode3 = SWIG_AsVal_int(obj2, &val3);
7749 if (!SWIG_IsOK(ecode3)) {
7750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7751 }
7752 arg3 = static_cast< int >(val3);
7753 {
7754 PyThreadState* __tstate = wxPyBeginAllowThreads();
7755 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7756 wxPyEndAllowThreads(__tstate);
7757 if (PyErr_Occurred()) SWIG_fail;
7758 }
7759 {
7760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7761 }
7762 return resultobj;
7763 fail:
7764 return NULL;
7765 }
7766
7767
7768 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7769 PyObject *resultobj = 0;
7770 wxRect *arg1 = (wxRect *) 0 ;
7771 wxPoint *arg2 = 0 ;
7772 bool result;
7773 void *argp1 = 0 ;
7774 int res1 = 0 ;
7775 wxPoint temp2 ;
7776 PyObject * obj0 = 0 ;
7777 PyObject * obj1 = 0 ;
7778 char * kwnames[] = {
7779 (char *) "self",(char *) "pt", NULL
7780 };
7781
7782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7784 if (!SWIG_IsOK(res1)) {
7785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7786 }
7787 arg1 = reinterpret_cast< wxRect * >(argp1);
7788 {
7789 arg2 = &temp2;
7790 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7791 }
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7795 wxPyEndAllowThreads(__tstate);
7796 if (PyErr_Occurred()) SWIG_fail;
7797 }
7798 {
7799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7800 }
7801 return resultobj;
7802 fail:
7803 return NULL;
7804 }
7805
7806
7807 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7808 PyObject *resultobj = 0;
7809 wxRect *arg1 = (wxRect *) 0 ;
7810 wxRect *arg2 = 0 ;
7811 bool result;
7812 void *argp1 = 0 ;
7813 int res1 = 0 ;
7814 wxRect temp2 ;
7815 PyObject * obj0 = 0 ;
7816 PyObject * obj1 = 0 ;
7817 char * kwnames[] = {
7818 (char *) "self",(char *) "rect", NULL
7819 };
7820
7821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7823 if (!SWIG_IsOK(res1)) {
7824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7825 }
7826 arg1 = reinterpret_cast< wxRect * >(argp1);
7827 {
7828 arg2 = &temp2;
7829 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7830 }
7831 {
7832 PyThreadState* __tstate = wxPyBeginAllowThreads();
7833 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7834 wxPyEndAllowThreads(__tstate);
7835 if (PyErr_Occurred()) SWIG_fail;
7836 }
7837 {
7838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7839 }
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7847 PyObject *resultobj = 0;
7848 wxRect *arg1 = (wxRect *) 0 ;
7849 wxRect *arg2 = 0 ;
7850 bool result;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 wxRect temp2 ;
7854 PyObject * obj0 = 0 ;
7855 PyObject * obj1 = 0 ;
7856 char * kwnames[] = {
7857 (char *) "self",(char *) "rect", NULL
7858 };
7859
7860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7862 if (!SWIG_IsOK(res1)) {
7863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7864 }
7865 arg1 = reinterpret_cast< wxRect * >(argp1);
7866 {
7867 arg2 = &temp2;
7868 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7869 }
7870 {
7871 PyThreadState* __tstate = wxPyBeginAllowThreads();
7872 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 {
7877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7878 }
7879 return resultobj;
7880 fail:
7881 return NULL;
7882 }
7883
7884
7885 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7886 PyObject *resultobj = 0;
7887 wxRect *arg1 = (wxRect *) 0 ;
7888 wxRect *arg2 = 0 ;
7889 int arg3 = (int) wxBOTH ;
7890 wxRect result;
7891 void *argp1 = 0 ;
7892 int res1 = 0 ;
7893 wxRect temp2 ;
7894 int val3 ;
7895 int ecode3 = 0 ;
7896 PyObject * obj0 = 0 ;
7897 PyObject * obj1 = 0 ;
7898 PyObject * obj2 = 0 ;
7899 char * kwnames[] = {
7900 (char *) "self",(char *) "r",(char *) "dir", NULL
7901 };
7902
7903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7905 if (!SWIG_IsOK(res1)) {
7906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7907 }
7908 arg1 = reinterpret_cast< wxRect * >(argp1);
7909 {
7910 arg2 = &temp2;
7911 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7912 }
7913 if (obj2) {
7914 ecode3 = SWIG_AsVal_int(obj2, &val3);
7915 if (!SWIG_IsOK(ecode3)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7917 }
7918 arg3 = static_cast< int >(val3);
7919 }
7920 {
7921 PyThreadState* __tstate = wxPyBeginAllowThreads();
7922 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7923 wxPyEndAllowThreads(__tstate);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *resultobj = 0;
7935 wxRect *arg1 = (wxRect *) 0 ;
7936 int arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 int val2 ;
7940 int ecode2 = 0 ;
7941 PyObject *swig_obj[2] ;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7952 }
7953 arg2 = static_cast< int >(val2);
7954 if (arg1) (arg1)->x = arg2;
7955
7956 resultobj = SWIG_Py_Void();
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965 wxRect *arg1 = (wxRect *) 0 ;
7966 int result;
7967 void *argp1 = 0 ;
7968 int res1 = 0 ;
7969 PyObject *swig_obj[1] ;
7970
7971 if (!args) SWIG_fail;
7972 swig_obj[0] = args;
7973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7976 }
7977 arg1 = reinterpret_cast< wxRect * >(argp1);
7978 result = (int) ((arg1)->x);
7979 resultobj = SWIG_From_int(static_cast< int >(result));
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 int val2 ;
7993 int ecode2 = 0 ;
7994 PyObject *swig_obj[2] ;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8003 if (!SWIG_IsOK(ecode2)) {
8004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8005 }
8006 arg2 = static_cast< int >(val2);
8007 if (arg1) (arg1)->y = arg2;
8008
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxRect *arg1 = (wxRect *) 0 ;
8019 int result;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8029 }
8030 arg1 = reinterpret_cast< wxRect * >(argp1);
8031 result = (int) ((arg1)->y);
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int arg2 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int val2 ;
8046 int ecode2 = 0 ;
8047 PyObject *swig_obj[2] ;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8058 }
8059 arg2 = static_cast< int >(val2);
8060 if (arg1) (arg1)->width = arg2;
8061
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxRect *arg1 = (wxRect *) 0 ;
8072 int result;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8082 }
8083 arg1 = reinterpret_cast< wxRect * >(argp1);
8084 result = (int) ((arg1)->width);
8085 resultobj = SWIG_From_int(static_cast< int >(result));
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int arg2 ;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 int val2 ;
8099 int ecode2 = 0 ;
8100 PyObject *swig_obj[2] ;
8101
8102 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 if (arg1) (arg1)->height = arg2;
8114
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 int result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 result = (int) ((arg1)->height);
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int arg2 = (int) 0 ;
8149 int arg3 = (int) 0 ;
8150 int arg4 = (int) 0 ;
8151 int arg5 = (int) 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 int val2 ;
8155 int ecode2 = 0 ;
8156 int val3 ;
8157 int ecode3 = 0 ;
8158 int val4 ;
8159 int ecode4 = 0 ;
8160 int val5 ;
8161 int ecode5 = 0 ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 PyObject * obj2 = 0 ;
8165 PyObject * obj3 = 0 ;
8166 PyObject * obj4 = 0 ;
8167 char * kwnames[] = {
8168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8169 };
8170
8171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8175 }
8176 arg1 = reinterpret_cast< wxRect * >(argp1);
8177 if (obj1) {
8178 ecode2 = SWIG_AsVal_int(obj1, &val2);
8179 if (!SWIG_IsOK(ecode2)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8181 }
8182 arg2 = static_cast< int >(val2);
8183 }
8184 if (obj2) {
8185 ecode3 = SWIG_AsVal_int(obj2, &val3);
8186 if (!SWIG_IsOK(ecode3)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8188 }
8189 arg3 = static_cast< int >(val3);
8190 }
8191 if (obj3) {
8192 ecode4 = SWIG_AsVal_int(obj3, &val4);
8193 if (!SWIG_IsOK(ecode4)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8195 }
8196 arg4 = static_cast< int >(val4);
8197 }
8198 if (obj4) {
8199 ecode5 = SWIG_AsVal_int(obj4, &val5);
8200 if (!SWIG_IsOK(ecode5)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8202 }
8203 arg5 = static_cast< int >(val5);
8204 }
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 resultobj = SWIG_Py_Void();
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxRect *arg1 = (wxRect *) 0 ;
8221 PyObject *result = 0 ;
8222 void *argp1 = 0 ;
8223 int res1 = 0 ;
8224 PyObject *swig_obj[1] ;
8225
8226 if (!args) SWIG_fail;
8227 swig_obj[0] = args;
8228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8229 if (!SWIG_IsOK(res1)) {
8230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8231 }
8232 arg1 = reinterpret_cast< wxRect * >(argp1);
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 result = (PyObject *)wxRect_Get(arg1);
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = result;
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8247 PyObject *obj;
8248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8249 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8250 return SWIG_Py_Void();
8251 }
8252
8253 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8254 return SWIG_Python_InitShadowInstance(args);
8255 }
8256
8257 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj = 0;
8259 wxRect *arg1 = (wxRect *) 0 ;
8260 wxRect *arg2 = (wxRect *) 0 ;
8261 PyObject *result = 0 ;
8262 void *argp1 = 0 ;
8263 int res1 = 0 ;
8264 void *argp2 = 0 ;
8265 int res2 = 0 ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char * kwnames[] = {
8269 (char *) "r1",(char *) "r2", NULL
8270 };
8271
8272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8274 if (!SWIG_IsOK(res1)) {
8275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8276 }
8277 arg1 = reinterpret_cast< wxRect * >(argp1);
8278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8279 if (!SWIG_IsOK(res2)) {
8280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8281 }
8282 arg2 = reinterpret_cast< wxRect * >(argp2);
8283 {
8284 if (!wxPyCheckForApp()) SWIG_fail;
8285 PyThreadState* __tstate = wxPyBeginAllowThreads();
8286 result = (PyObject *)wxIntersectRect(arg1,arg2);
8287 wxPyEndAllowThreads(__tstate);
8288 if (PyErr_Occurred()) SWIG_fail;
8289 }
8290 resultobj = result;
8291 return resultobj;
8292 fail:
8293 return NULL;
8294 }
8295
8296
8297 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8298 PyObject *resultobj = 0;
8299 double arg1 = (double) 0.0 ;
8300 double arg2 = (double) 0.0 ;
8301 wxPoint2D *result = 0 ;
8302 double val1 ;
8303 int ecode1 = 0 ;
8304 double val2 ;
8305 int ecode2 = 0 ;
8306 PyObject * obj0 = 0 ;
8307 PyObject * obj1 = 0 ;
8308 char * kwnames[] = {
8309 (char *) "x",(char *) "y", NULL
8310 };
8311
8312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8313 if (obj0) {
8314 ecode1 = SWIG_AsVal_double(obj0, &val1);
8315 if (!SWIG_IsOK(ecode1)) {
8316 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8317 }
8318 arg1 = static_cast< double >(val1);
8319 }
8320 if (obj1) {
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 }
8327 {
8328 PyThreadState* __tstate = wxPyBeginAllowThreads();
8329 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8330 wxPyEndAllowThreads(__tstate);
8331 if (PyErr_Occurred()) SWIG_fail;
8332 }
8333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8334 return resultobj;
8335 fail:
8336 return NULL;
8337 }
8338
8339
8340 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8341 PyObject *resultobj = 0;
8342 wxPoint2D *arg1 = 0 ;
8343 wxPoint2D *result = 0 ;
8344 wxPoint2D temp1 ;
8345 PyObject * obj0 = 0 ;
8346 char * kwnames[] = {
8347 (char *) "pt", NULL
8348 };
8349
8350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8351 {
8352 arg1 = &temp1;
8353 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8354 }
8355 {
8356 PyThreadState* __tstate = wxPyBeginAllowThreads();
8357 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8358 wxPyEndAllowThreads(__tstate);
8359 if (PyErr_Occurred()) SWIG_fail;
8360 }
8361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8362 return resultobj;
8363 fail:
8364 return NULL;
8365 }
8366
8367
8368 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8369 PyObject *resultobj = 0;
8370 wxPoint *arg1 = 0 ;
8371 wxPoint2D *result = 0 ;
8372 wxPoint temp1 ;
8373 PyObject * obj0 = 0 ;
8374 char * kwnames[] = {
8375 (char *) "pt", NULL
8376 };
8377
8378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8379 {
8380 arg1 = &temp1;
8381 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8382 }
8383 {
8384 PyThreadState* __tstate = wxPyBeginAllowThreads();
8385 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8390 return resultobj;
8391 fail:
8392 return NULL;
8393 }
8394
8395
8396 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8397 PyObject *resultobj = 0;
8398 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8399 void *argp1 = 0 ;
8400 int res1 = 0 ;
8401 PyObject *swig_obj[1] ;
8402
8403 if (!args) SWIG_fail;
8404 swig_obj[0] = args;
8405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8406 if (!SWIG_IsOK(res1)) {
8407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8408 }
8409 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8410 {
8411 PyThreadState* __tstate = wxPyBeginAllowThreads();
8412 delete arg1;
8413
8414 wxPyEndAllowThreads(__tstate);
8415 if (PyErr_Occurred()) SWIG_fail;
8416 }
8417 resultobj = SWIG_Py_Void();
8418 return resultobj;
8419 fail:
8420 return NULL;
8421 }
8422
8423
8424 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 PyObject *resultobj = 0;
8426 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8427 int *arg2 = (int *) 0 ;
8428 int *arg3 = (int *) 0 ;
8429 void *argp1 = 0 ;
8430 int res1 = 0 ;
8431 int temp2 ;
8432 int res2 = SWIG_TMPOBJ ;
8433 int temp3 ;
8434 int res3 = SWIG_TMPOBJ ;
8435 PyObject *swig_obj[1] ;
8436
8437 arg2 = &temp2;
8438 arg3 = &temp3;
8439 if (!args) SWIG_fail;
8440 swig_obj[0] = args;
8441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8442 if (!SWIG_IsOK(res1)) {
8443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8444 }
8445 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8446 {
8447 PyThreadState* __tstate = wxPyBeginAllowThreads();
8448 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8449 wxPyEndAllowThreads(__tstate);
8450 if (PyErr_Occurred()) SWIG_fail;
8451 }
8452 resultobj = SWIG_Py_Void();
8453 if (SWIG_IsTmpObj(res2)) {
8454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8455 } else {
8456 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8458 }
8459 if (SWIG_IsTmpObj(res3)) {
8460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8461 } else {
8462 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8464 }
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 int *arg2 = (int *) 0 ;
8475 int *arg3 = (int *) 0 ;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 int temp2 ;
8479 int res2 = SWIG_TMPOBJ ;
8480 int temp3 ;
8481 int res3 = SWIG_TMPOBJ ;
8482 PyObject *swig_obj[1] ;
8483
8484 arg2 = &temp2;
8485 arg3 = &temp3;
8486 if (!args) SWIG_fail;
8487 swig_obj[0] = args;
8488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8491 }
8492 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8493 {
8494 PyThreadState* __tstate = wxPyBeginAllowThreads();
8495 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8496 wxPyEndAllowThreads(__tstate);
8497 if (PyErr_Occurred()) SWIG_fail;
8498 }
8499 resultobj = SWIG_Py_Void();
8500 if (SWIG_IsTmpObj(res2)) {
8501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8502 } else {
8503 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8505 }
8506 if (SWIG_IsTmpObj(res3)) {
8507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8508 } else {
8509 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8511 }
8512 return resultobj;
8513 fail:
8514 return NULL;
8515 }
8516
8517
8518 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8519 PyObject *resultobj = 0;
8520 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8521 double result;
8522 void *argp1 = 0 ;
8523 int res1 = 0 ;
8524 PyObject *swig_obj[1] ;
8525
8526 if (!args) SWIG_fail;
8527 swig_obj[0] = args;
8528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8529 if (!SWIG_IsOK(res1)) {
8530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8531 }
8532 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8533 {
8534 PyThreadState* __tstate = wxPyBeginAllowThreads();
8535 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8536 wxPyEndAllowThreads(__tstate);
8537 if (PyErr_Occurred()) SWIG_fail;
8538 }
8539 resultobj = SWIG_From_double(static_cast< double >(result));
8540 return resultobj;
8541 fail:
8542 return NULL;
8543 }
8544
8545
8546 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8547 PyObject *resultobj = 0;
8548 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8549 double result;
8550 void *argp1 = 0 ;
8551 int res1 = 0 ;
8552 PyObject *swig_obj[1] ;
8553
8554 if (!args) SWIG_fail;
8555 swig_obj[0] = args;
8556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8557 if (!SWIG_IsOK(res1)) {
8558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8559 }
8560 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 resultobj = SWIG_From_double(static_cast< double >(result));
8568 return resultobj;
8569 fail:
8570 return NULL;
8571 }
8572
8573
8574 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8575 PyObject *resultobj = 0;
8576 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8577 double arg2 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 double val2 ;
8581 int ecode2 = 0 ;
8582 PyObject * obj0 = 0 ;
8583 PyObject * obj1 = 0 ;
8584 char * kwnames[] = {
8585 (char *) "self",(char *) "length", NULL
8586 };
8587
8588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8590 if (!SWIG_IsOK(res1)) {
8591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8592 }
8593 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8594 ecode2 = SWIG_AsVal_double(obj1, &val2);
8595 if (!SWIG_IsOK(ecode2)) {
8596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8597 }
8598 arg2 = static_cast< double >(val2);
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 (arg1)->SetVectorLength(arg2);
8602 wxPyEndAllowThreads(__tstate);
8603 if (PyErr_Occurred()) SWIG_fail;
8604 }
8605 resultobj = SWIG_Py_Void();
8606 return resultobj;
8607 fail:
8608 return NULL;
8609 }
8610
8611
8612 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8613 PyObject *resultobj = 0;
8614 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8615 double arg2 ;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 double val2 ;
8619 int ecode2 = 0 ;
8620 PyObject * obj0 = 0 ;
8621 PyObject * obj1 = 0 ;
8622 char * kwnames[] = {
8623 (char *) "self",(char *) "degrees", NULL
8624 };
8625
8626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8628 if (!SWIG_IsOK(res1)) {
8629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8630 }
8631 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8632 ecode2 = SWIG_AsVal_double(obj1, &val2);
8633 if (!SWIG_IsOK(ecode2)) {
8634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8635 }
8636 arg2 = static_cast< double >(val2);
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 (arg1)->SetVectorAngle(arg2);
8640 wxPyEndAllowThreads(__tstate);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 wxPoint2D *arg2 = 0 ;
8654 double result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxPoint2D temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "pt", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 PyThreadState* __tstate = wxPyBeginAllowThreads();
8676 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 resultobj = SWIG_From_double(static_cast< double >(result));
8681 return resultobj;
8682 fail:
8683 return NULL;
8684 }
8685
8686
8687 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8688 PyObject *resultobj = 0;
8689 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8690 wxPoint2D *arg2 = 0 ;
8691 double result;
8692 void *argp1 = 0 ;
8693 int res1 = 0 ;
8694 wxPoint2D temp2 ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char * kwnames[] = {
8698 (char *) "self",(char *) "pt", NULL
8699 };
8700
8701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8703 if (!SWIG_IsOK(res1)) {
8704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8705 }
8706 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8707 {
8708 arg2 = &temp2;
8709 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8714 wxPyEndAllowThreads(__tstate);
8715 if (PyErr_Occurred()) SWIG_fail;
8716 }
8717 resultobj = SWIG_From_double(static_cast< double >(result));
8718 return resultobj;
8719 fail:
8720 return NULL;
8721 }
8722
8723
8724 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8725 PyObject *resultobj = 0;
8726 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8727 wxPoint2D *arg2 = 0 ;
8728 double result;
8729 void *argp1 = 0 ;
8730 int res1 = 0 ;
8731 wxPoint2D temp2 ;
8732 PyObject * obj0 = 0 ;
8733 PyObject * obj1 = 0 ;
8734 char * kwnames[] = {
8735 (char *) "self",(char *) "vec", NULL
8736 };
8737
8738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8740 if (!SWIG_IsOK(res1)) {
8741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8742 }
8743 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8744 {
8745 arg2 = &temp2;
8746 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8747 }
8748 {
8749 PyThreadState* __tstate = wxPyBeginAllowThreads();
8750 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8751 wxPyEndAllowThreads(__tstate);
8752 if (PyErr_Occurred()) SWIG_fail;
8753 }
8754 resultobj = SWIG_From_double(static_cast< double >(result));
8755 return resultobj;
8756 fail:
8757 return NULL;
8758 }
8759
8760
8761 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8762 PyObject *resultobj = 0;
8763 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8764 wxPoint2D *arg2 = 0 ;
8765 double result;
8766 void *argp1 = 0 ;
8767 int res1 = 0 ;
8768 wxPoint2D temp2 ;
8769 PyObject * obj0 = 0 ;
8770 PyObject * obj1 = 0 ;
8771 char * kwnames[] = {
8772 (char *) "self",(char *) "vec", NULL
8773 };
8774
8775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 {
8782 arg2 = &temp2;
8783 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8784 }
8785 {
8786 PyThreadState* __tstate = wxPyBeginAllowThreads();
8787 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8788 wxPyEndAllowThreads(__tstate);
8789 if (PyErr_Occurred()) SWIG_fail;
8790 }
8791 resultobj = SWIG_From_double(static_cast< double >(result));
8792 return resultobj;
8793 fail:
8794 return NULL;
8795 }
8796
8797
8798 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8799 PyObject *resultobj = 0;
8800 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8801 wxPoint2D result;
8802 void *argp1 = 0 ;
8803 int res1 = 0 ;
8804 PyObject *swig_obj[1] ;
8805
8806 if (!args) SWIG_fail;
8807 swig_obj[0] = args;
8808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 {
8814 PyThreadState* __tstate = wxPyBeginAllowThreads();
8815 result = (arg1)->operator -();
8816 wxPyEndAllowThreads(__tstate);
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8820 return resultobj;
8821 fail:
8822 return NULL;
8823 }
8824
8825
8826 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj = 0;
8828 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8829 wxPoint2D *arg2 = 0 ;
8830 wxPoint2D *result = 0 ;
8831 void *argp1 = 0 ;
8832 int res1 = 0 ;
8833 wxPoint2D temp2 ;
8834 PyObject * obj0 = 0 ;
8835 PyObject * obj1 = 0 ;
8836 char * kwnames[] = {
8837 (char *) "self",(char *) "pt", NULL
8838 };
8839
8840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 {
8847 arg2 = &temp2;
8848 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8849 }
8850 {
8851 PyThreadState* __tstate = wxPyBeginAllowThreads();
8852 {
8853 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8854 result = (wxPoint2D *) &_result_ref;
8855 }
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8860 return resultobj;
8861 fail:
8862 return NULL;
8863 }
8864
8865
8866 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8867 PyObject *resultobj = 0;
8868 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8869 wxPoint2D *arg2 = 0 ;
8870 wxPoint2D *result = 0 ;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 wxPoint2D temp2 ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 char * kwnames[] = {
8877 (char *) "self",(char *) "pt", NULL
8878 };
8879
8880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8882 if (!SWIG_IsOK(res1)) {
8883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8884 }
8885 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8886 {
8887 arg2 = &temp2;
8888 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8889 }
8890 {
8891 PyThreadState* __tstate = wxPyBeginAllowThreads();
8892 {
8893 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8894 result = (wxPoint2D *) &_result_ref;
8895 }
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 wxPoint2D *arg2 = 0 ;
8910 wxPoint2D *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 wxPoint2D temp2 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "pt", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 {
8927 arg2 = &temp2;
8928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 {
8933 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8934 result = (wxPoint2D *) &_result_ref;
8935 }
8936 wxPyEndAllowThreads(__tstate);
8937 if (PyErr_Occurred()) SWIG_fail;
8938 }
8939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8940 return resultobj;
8941 fail:
8942 return NULL;
8943 }
8944
8945
8946 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8947 PyObject *resultobj = 0;
8948 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8949 wxPoint2D *arg2 = 0 ;
8950 wxPoint2D *result = 0 ;
8951 void *argp1 = 0 ;
8952 int res1 = 0 ;
8953 wxPoint2D temp2 ;
8954 PyObject * obj0 = 0 ;
8955 PyObject * obj1 = 0 ;
8956 char * kwnames[] = {
8957 (char *) "self",(char *) "pt", NULL
8958 };
8959
8960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8962 if (!SWIG_IsOK(res1)) {
8963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8964 }
8965 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8966 {
8967 arg2 = &temp2;
8968 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8969 }
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 {
8973 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8974 result = (wxPoint2D *) &_result_ref;
8975 }
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8987 PyObject *resultobj = 0;
8988 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8989 PyObject *arg2 = (PyObject *) 0 ;
8990 bool result;
8991 void *argp1 = 0 ;
8992 int res1 = 0 ;
8993 PyObject * obj0 = 0 ;
8994 PyObject * obj1 = 0 ;
8995 char * kwnames[] = {
8996 (char *) "self",(char *) "other", NULL
8997 };
8998
8999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
9000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9001 if (!SWIG_IsOK(res1)) {
9002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9003 }
9004 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9005 arg2 = obj1;
9006 {
9007 result = (bool)wxPoint2D___eq__(arg1,arg2);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 {
9011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9012 }
9013 return resultobj;
9014 fail:
9015 return NULL;
9016 }
9017
9018
9019 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9020 PyObject *resultobj = 0;
9021 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9022 PyObject *arg2 = (PyObject *) 0 ;
9023 bool result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject * obj0 = 0 ;
9027 PyObject * obj1 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "self",(char *) "other", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9034 if (!SWIG_IsOK(res1)) {
9035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9036 }
9037 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9038 arg2 = obj1;
9039 {
9040 result = (bool)wxPoint2D___ne__(arg1,arg2);
9041 if (PyErr_Occurred()) SWIG_fail;
9042 }
9043 {
9044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9045 }
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9053 PyObject *resultobj = 0;
9054 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9055 double arg2 ;
9056 void *argp1 = 0 ;
9057 int res1 = 0 ;
9058 double val2 ;
9059 int ecode2 = 0 ;
9060 PyObject *swig_obj[2] ;
9061
9062 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9064 if (!SWIG_IsOK(res1)) {
9065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9066 }
9067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9068 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9069 if (!SWIG_IsOK(ecode2)) {
9070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9071 }
9072 arg2 = static_cast< double >(val2);
9073 if (arg1) (arg1)->m_x = arg2;
9074
9075 resultobj = SWIG_Py_Void();
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9083 PyObject *resultobj = 0;
9084 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9085 double result;
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_wxPoint2D, 0 | 0 );
9093 if (!SWIG_IsOK(res1)) {
9094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9095 }
9096 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9097 result = (double) ((arg1)->m_x);
9098 resultobj = SWIG_From_double(static_cast< double >(result));
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *resultobj = 0;
9107 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9108 double arg2 ;
9109 void *argp1 = 0 ;
9110 int res1 = 0 ;
9111 double val2 ;
9112 int ecode2 = 0 ;
9113 PyObject *swig_obj[2] ;
9114
9115 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9117 if (!SWIG_IsOK(res1)) {
9118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9119 }
9120 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9121 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9122 if (!SWIG_IsOK(ecode2)) {
9123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9124 }
9125 arg2 = static_cast< double >(val2);
9126 if (arg1) (arg1)->m_y = arg2;
9127
9128 resultobj = SWIG_Py_Void();
9129 return resultobj;
9130 fail:
9131 return NULL;
9132 }
9133
9134
9135 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9136 PyObject *resultobj = 0;
9137 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9138 double result;
9139 void *argp1 = 0 ;
9140 int res1 = 0 ;
9141 PyObject *swig_obj[1] ;
9142
9143 if (!args) SWIG_fail;
9144 swig_obj[0] = args;
9145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9146 if (!SWIG_IsOK(res1)) {
9147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9148 }
9149 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9150 result = (double) ((arg1)->m_y);
9151 resultobj = SWIG_From_double(static_cast< double >(result));
9152 return resultobj;
9153 fail:
9154 return NULL;
9155 }
9156
9157
9158 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9159 PyObject *resultobj = 0;
9160 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9161 double arg2 = (double) 0 ;
9162 double arg3 = (double) 0 ;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 double val2 ;
9166 int ecode2 = 0 ;
9167 double val3 ;
9168 int ecode3 = 0 ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 PyObject * obj2 = 0 ;
9172 char * kwnames[] = {
9173 (char *) "self",(char *) "x",(char *) "y", NULL
9174 };
9175
9176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9178 if (!SWIG_IsOK(res1)) {
9179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9180 }
9181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9182 if (obj1) {
9183 ecode2 = SWIG_AsVal_double(obj1, &val2);
9184 if (!SWIG_IsOK(ecode2)) {
9185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9186 }
9187 arg2 = static_cast< double >(val2);
9188 }
9189 if (obj2) {
9190 ecode3 = SWIG_AsVal_double(obj2, &val3);
9191 if (!SWIG_IsOK(ecode3)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9193 }
9194 arg3 = static_cast< double >(val3);
9195 }
9196 {
9197 PyThreadState* __tstate = wxPyBeginAllowThreads();
9198 wxPoint2D_Set(arg1,arg2,arg3);
9199 wxPyEndAllowThreads(__tstate);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = SWIG_Py_Void();
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9210 PyObject *resultobj = 0;
9211 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9212 PyObject *result = 0 ;
9213 void *argp1 = 0 ;
9214 int res1 = 0 ;
9215 PyObject *swig_obj[1] ;
9216
9217 if (!args) SWIG_fail;
9218 swig_obj[0] = args;
9219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9220 if (!SWIG_IsOK(res1)) {
9221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9222 }
9223 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = (PyObject *)wxPoint2D_Get(arg1);
9227 wxPyEndAllowThreads(__tstate);
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = result;
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *obj;
9239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9240 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9241 return SWIG_Py_Void();
9242 }
9243
9244 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9245 return SWIG_Python_InitShadowInstance(args);
9246 }
9247
9248 SWIGINTERN int DefaultPosition_set(PyObject *) {
9249 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9250 return 1;
9251 }
9252
9253
9254 SWIGINTERN PyObject *DefaultPosition_get(void) {
9255 PyObject *pyobj = 0;
9256
9257 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9258 return pyobj;
9259 }
9260
9261
9262 SWIGINTERN int DefaultSize_set(PyObject *) {
9263 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9264 return 1;
9265 }
9266
9267
9268 SWIGINTERN PyObject *DefaultSize_get(void) {
9269 PyObject *pyobj = 0;
9270
9271 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9272 return pyobj;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj = 0;
9278 PyObject *arg1 = (PyObject *) 0 ;
9279 wxPyInputStream *result = 0 ;
9280 PyObject * obj0 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "p", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9286 arg1 = obj0;
9287 {
9288 PyThreadState* __tstate = wxPyBeginAllowThreads();
9289 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9290 wxPyEndAllowThreads(__tstate);
9291 if (PyErr_Occurred()) SWIG_fail;
9292 }
9293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9294 return resultobj;
9295 fail:
9296 return NULL;
9297 }
9298
9299
9300 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 PyObject *resultobj = 0;
9302 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9312 }
9313 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 delete arg1;
9317
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_Py_Void();
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9340 }
9341 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 (arg1)->close();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 resultobj = SWIG_Py_Void();
9349 return resultobj;
9350 fail:
9351 return NULL;
9352 }
9353
9354
9355 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9356 PyObject *resultobj = 0;
9357 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9358 void *argp1 = 0 ;
9359 int res1 = 0 ;
9360 PyObject *swig_obj[1] ;
9361
9362 if (!args) SWIG_fail;
9363 swig_obj[0] = args;
9364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 {
9370 PyThreadState* __tstate = wxPyBeginAllowThreads();
9371 (arg1)->flush();
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 resultobj = SWIG_Py_Void();
9376 return resultobj;
9377 fail:
9378 return NULL;
9379 }
9380
9381
9382 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9383 PyObject *resultobj = 0;
9384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9385 bool result;
9386 void *argp1 = 0 ;
9387 int res1 = 0 ;
9388 PyObject *swig_obj[1] ;
9389
9390 if (!args) SWIG_fail;
9391 swig_obj[0] = args;
9392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9393 if (!SWIG_IsOK(res1)) {
9394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9395 }
9396 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (bool)(arg1)->eof();
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 {
9404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9405 }
9406 return resultobj;
9407 fail:
9408 return NULL;
9409 }
9410
9411
9412 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9413 PyObject *resultobj = 0;
9414 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9415 int arg2 = (int) -1 ;
9416 PyObject *result = 0 ;
9417 void *argp1 = 0 ;
9418 int res1 = 0 ;
9419 int val2 ;
9420 int ecode2 = 0 ;
9421 PyObject * obj0 = 0 ;
9422 PyObject * obj1 = 0 ;
9423 char * kwnames[] = {
9424 (char *) "self",(char *) "size", NULL
9425 };
9426
9427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9429 if (!SWIG_IsOK(res1)) {
9430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9431 }
9432 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9433 if (obj1) {
9434 ecode2 = SWIG_AsVal_int(obj1, &val2);
9435 if (!SWIG_IsOK(ecode2)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9437 }
9438 arg2 = static_cast< int >(val2);
9439 }
9440 {
9441 PyThreadState* __tstate = wxPyBeginAllowThreads();
9442 result = (PyObject *)(arg1)->read(arg2);
9443 wxPyEndAllowThreads(__tstate);
9444 if (PyErr_Occurred()) SWIG_fail;
9445 }
9446 resultobj = result;
9447 return resultobj;
9448 fail:
9449 return NULL;
9450 }
9451
9452
9453 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9454 PyObject *resultobj = 0;
9455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9456 int arg2 = (int) -1 ;
9457 PyObject *result = 0 ;
9458 void *argp1 = 0 ;
9459 int res1 = 0 ;
9460 int val2 ;
9461 int ecode2 = 0 ;
9462 PyObject * obj0 = 0 ;
9463 PyObject * obj1 = 0 ;
9464 char * kwnames[] = {
9465 (char *) "self",(char *) "size", NULL
9466 };
9467
9468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 if (obj1) {
9475 ecode2 = SWIG_AsVal_int(obj1, &val2);
9476 if (!SWIG_IsOK(ecode2)) {
9477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9478 }
9479 arg2 = static_cast< int >(val2);
9480 }
9481 {
9482 PyThreadState* __tstate = wxPyBeginAllowThreads();
9483 result = (PyObject *)(arg1)->readline(arg2);
9484 wxPyEndAllowThreads(__tstate);
9485 if (PyErr_Occurred()) SWIG_fail;
9486 }
9487 resultobj = result;
9488 return resultobj;
9489 fail:
9490 return NULL;
9491 }
9492
9493
9494 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9495 PyObject *resultobj = 0;
9496 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9497 int arg2 = (int) -1 ;
9498 PyObject *result = 0 ;
9499 void *argp1 = 0 ;
9500 int res1 = 0 ;
9501 int val2 ;
9502 int ecode2 = 0 ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 char * kwnames[] = {
9506 (char *) "self",(char *) "sizehint", NULL
9507 };
9508
9509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9511 if (!SWIG_IsOK(res1)) {
9512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9513 }
9514 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9515 if (obj1) {
9516 ecode2 = SWIG_AsVal_int(obj1, &val2);
9517 if (!SWIG_IsOK(ecode2)) {
9518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9519 }
9520 arg2 = static_cast< int >(val2);
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 result = (PyObject *)(arg1)->readlines(arg2);
9525 wxPyEndAllowThreads(__tstate);
9526 if (PyErr_Occurred()) SWIG_fail;
9527 }
9528 resultobj = result;
9529 return resultobj;
9530 fail:
9531 return NULL;
9532 }
9533
9534
9535 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9536 PyObject *resultobj = 0;
9537 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9538 int arg2 ;
9539 int arg3 = (int) 0 ;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 int val2 ;
9543 int ecode2 = 0 ;
9544 int val3 ;
9545 int ecode3 = 0 ;
9546 PyObject * obj0 = 0 ;
9547 PyObject * obj1 = 0 ;
9548 PyObject * obj2 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "offset",(char *) "whence", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9557 }
9558 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9559 ecode2 = SWIG_AsVal_int(obj1, &val2);
9560 if (!SWIG_IsOK(ecode2)) {
9561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9562 }
9563 arg2 = static_cast< int >(val2);
9564 if (obj2) {
9565 ecode3 = SWIG_AsVal_int(obj2, &val3);
9566 if (!SWIG_IsOK(ecode3)) {
9567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9568 }
9569 arg3 = static_cast< int >(val3);
9570 }
9571 {
9572 PyThreadState* __tstate = wxPyBeginAllowThreads();
9573 (arg1)->seek(arg2,arg3);
9574 wxPyEndAllowThreads(__tstate);
9575 if (PyErr_Occurred()) SWIG_fail;
9576 }
9577 resultobj = SWIG_Py_Void();
9578 return resultobj;
9579 fail:
9580 return NULL;
9581 }
9582
9583
9584 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9585 PyObject *resultobj = 0;
9586 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9587 int result;
9588 void *argp1 = 0 ;
9589 int res1 = 0 ;
9590 PyObject *swig_obj[1] ;
9591
9592 if (!args) SWIG_fail;
9593 swig_obj[0] = args;
9594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9595 if (!SWIG_IsOK(res1)) {
9596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9597 }
9598 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9599 {
9600 PyThreadState* __tstate = wxPyBeginAllowThreads();
9601 result = (int)(arg1)->tell();
9602 wxPyEndAllowThreads(__tstate);
9603 if (PyErr_Occurred()) SWIG_fail;
9604 }
9605 resultobj = SWIG_From_int(static_cast< int >(result));
9606 return resultobj;
9607 fail:
9608 return NULL;
9609 }
9610
9611
9612 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9613 PyObject *resultobj = 0;
9614 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9615 char result;
9616 void *argp1 = 0 ;
9617 int res1 = 0 ;
9618 PyObject *swig_obj[1] ;
9619
9620 if (!args) SWIG_fail;
9621 swig_obj[0] = args;
9622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9623 if (!SWIG_IsOK(res1)) {
9624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9625 }
9626 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (char)(arg1)->Peek();
9630 wxPyEndAllowThreads(__tstate);
9631 if (PyErr_Occurred()) SWIG_fail;
9632 }
9633 resultobj = SWIG_From_char(static_cast< char >(result));
9634 return resultobj;
9635 fail:
9636 return NULL;
9637 }
9638
9639
9640 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9641 PyObject *resultobj = 0;
9642 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9643 char result;
9644 void *argp1 = 0 ;
9645 int res1 = 0 ;
9646 PyObject *swig_obj[1] ;
9647
9648 if (!args) SWIG_fail;
9649 swig_obj[0] = args;
9650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9651 if (!SWIG_IsOK(res1)) {
9652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9653 }
9654 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9655 {
9656 PyThreadState* __tstate = wxPyBeginAllowThreads();
9657 result = (char)(arg1)->GetC();
9658 wxPyEndAllowThreads(__tstate);
9659 if (PyErr_Occurred()) SWIG_fail;
9660 }
9661 resultobj = SWIG_From_char(static_cast< char >(result));
9662 return resultobj;
9663 fail:
9664 return NULL;
9665 }
9666
9667
9668 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9669 PyObject *resultobj = 0;
9670 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9671 size_t result;
9672 void *argp1 = 0 ;
9673 int res1 = 0 ;
9674 PyObject *swig_obj[1] ;
9675
9676 if (!args) SWIG_fail;
9677 swig_obj[0] = args;
9678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9679 if (!SWIG_IsOK(res1)) {
9680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9681 }
9682 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9683 {
9684 PyThreadState* __tstate = wxPyBeginAllowThreads();
9685 result = (size_t)(arg1)->LastRead();
9686 wxPyEndAllowThreads(__tstate);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9697 PyObject *resultobj = 0;
9698 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9699 bool result;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 PyObject *swig_obj[1] ;
9703
9704 if (!args) SWIG_fail;
9705 swig_obj[0] = args;
9706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9707 if (!SWIG_IsOK(res1)) {
9708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9709 }
9710 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9711 {
9712 PyThreadState* __tstate = wxPyBeginAllowThreads();
9713 result = (bool)(arg1)->CanRead();
9714 wxPyEndAllowThreads(__tstate);
9715 if (PyErr_Occurred()) SWIG_fail;
9716 }
9717 {
9718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9719 }
9720 return resultobj;
9721 fail:
9722 return NULL;
9723 }
9724
9725
9726 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9727 PyObject *resultobj = 0;
9728 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9729 bool result;
9730 void *argp1 = 0 ;
9731 int res1 = 0 ;
9732 PyObject *swig_obj[1] ;
9733
9734 if (!args) SWIG_fail;
9735 swig_obj[0] = args;
9736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9737 if (!SWIG_IsOK(res1)) {
9738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9739 }
9740 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9741 {
9742 PyThreadState* __tstate = wxPyBeginAllowThreads();
9743 result = (bool)(arg1)->Eof();
9744 wxPyEndAllowThreads(__tstate);
9745 if (PyErr_Occurred()) SWIG_fail;
9746 }
9747 {
9748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9749 }
9750 return resultobj;
9751 fail:
9752 return NULL;
9753 }
9754
9755
9756 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9757 PyObject *resultobj = 0;
9758 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9759 char arg2 ;
9760 bool result;
9761 void *argp1 = 0 ;
9762 int res1 = 0 ;
9763 char val2 ;
9764 int ecode2 = 0 ;
9765 PyObject * obj0 = 0 ;
9766 PyObject * obj1 = 0 ;
9767 char * kwnames[] = {
9768 (char *) "self",(char *) "c", NULL
9769 };
9770
9771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9773 if (!SWIG_IsOK(res1)) {
9774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9775 }
9776 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9777 ecode2 = SWIG_AsVal_char(obj1, &val2);
9778 if (!SWIG_IsOK(ecode2)) {
9779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9780 }
9781 arg2 = static_cast< char >(val2);
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (bool)(arg1)->Ungetch(arg2);
9785 wxPyEndAllowThreads(__tstate);
9786 if (PyErr_Occurred()) SWIG_fail;
9787 }
9788 {
9789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9790 }
9791 return resultobj;
9792 fail:
9793 return NULL;
9794 }
9795
9796
9797 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj = 0;
9799 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9800 long arg2 ;
9801 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9802 long result;
9803 void *argp1 = 0 ;
9804 int res1 = 0 ;
9805 long val2 ;
9806 int ecode2 = 0 ;
9807 int val3 ;
9808 int ecode3 = 0 ;
9809 PyObject * obj0 = 0 ;
9810 PyObject * obj1 = 0 ;
9811 PyObject * obj2 = 0 ;
9812 char * kwnames[] = {
9813 (char *) "self",(char *) "pos",(char *) "mode", NULL
9814 };
9815
9816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9820 }
9821 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9822 ecode2 = SWIG_AsVal_long(obj1, &val2);
9823 if (!SWIG_IsOK(ecode2)) {
9824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9825 }
9826 arg2 = static_cast< long >(val2);
9827 if (obj2) {
9828 ecode3 = SWIG_AsVal_int(obj2, &val3);
9829 if (!SWIG_IsOK(ecode3)) {
9830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9831 }
9832 arg3 = static_cast< wxSeekMode >(val3);
9833 }
9834 {
9835 PyThreadState* __tstate = wxPyBeginAllowThreads();
9836 result = (long)(arg1)->SeekI(arg2,arg3);
9837 wxPyEndAllowThreads(__tstate);
9838 if (PyErr_Occurred()) SWIG_fail;
9839 }
9840 resultobj = SWIG_From_long(static_cast< long >(result));
9841 return resultobj;
9842 fail:
9843 return NULL;
9844 }
9845
9846
9847 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9848 PyObject *resultobj = 0;
9849 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9850 long result;
9851 void *argp1 = 0 ;
9852 int res1 = 0 ;
9853 PyObject *swig_obj[1] ;
9854
9855 if (!args) SWIG_fail;
9856 swig_obj[0] = args;
9857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9858 if (!SWIG_IsOK(res1)) {
9859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9860 }
9861 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (long)(arg1)->TellI();
9865 wxPyEndAllowThreads(__tstate);
9866 if (PyErr_Occurred()) SWIG_fail;
9867 }
9868 resultobj = SWIG_From_long(static_cast< long >(result));
9869 return resultobj;
9870 fail:
9871 return NULL;
9872 }
9873
9874
9875 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9876 PyObject *obj;
9877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9878 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9879 return SWIG_Py_Void();
9880 }
9881
9882 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9883 return SWIG_Python_InitShadowInstance(args);
9884 }
9885
9886 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9887 PyObject *resultobj = 0;
9888 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9889 PyObject *arg2 = (PyObject *) 0 ;
9890 void *argp1 = 0 ;
9891 int res1 = 0 ;
9892 PyObject * obj0 = 0 ;
9893 PyObject * obj1 = 0 ;
9894 char * kwnames[] = {
9895 (char *) "self",(char *) "obj", NULL
9896 };
9897
9898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9900 if (!SWIG_IsOK(res1)) {
9901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9902 }
9903 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9904 arg2 = obj1;
9905 {
9906 PyThreadState* __tstate = wxPyBeginAllowThreads();
9907 wxOutputStream_write(arg1,arg2);
9908 wxPyEndAllowThreads(__tstate);
9909 if (PyErr_Occurred()) SWIG_fail;
9910 }
9911 resultobj = SWIG_Py_Void();
9912 return resultobj;
9913 fail:
9914 return NULL;
9915 }
9916
9917
9918 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9919 PyObject *resultobj = 0;
9920 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9921 size_t result;
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_wxOutputStream, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9931 }
9932 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *obj;
9948 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9949 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9950 return SWIG_Py_Void();
9951 }
9952
9953 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxInputStream *arg1 = (wxInputStream *) 0 ;
9956 wxString *arg2 = 0 ;
9957 wxString *arg3 = 0 ;
9958 wxString *arg4 = 0 ;
9959 wxDateTime arg5 ;
9960 wxFSFile *result = 0 ;
9961 wxPyInputStream *temp1 ;
9962 bool temp2 = false ;
9963 bool temp3 = false ;
9964 bool temp4 = false ;
9965 void *argp5 ;
9966 int res5 = 0 ;
9967 PyObject * obj0 = 0 ;
9968 PyObject * obj1 = 0 ;
9969 PyObject * obj2 = 0 ;
9970 PyObject * obj3 = 0 ;
9971 PyObject * obj4 = 0 ;
9972 char * kwnames[] = {
9973 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9974 };
9975
9976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9977 {
9978 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9979 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9980 } else {
9981 PyErr_Clear(); // clear the failure of the wxPyConvert above
9982 arg1 = wxPyCBInputStream_create(obj0, true);
9983 if (arg1 == NULL) {
9984 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9985 SWIG_fail;
9986 }
9987 }
9988 }
9989 {
9990 arg2 = wxString_in_helper(obj1);
9991 if (arg2 == NULL) SWIG_fail;
9992 temp2 = true;
9993 }
9994 {
9995 arg3 = wxString_in_helper(obj2);
9996 if (arg3 == NULL) SWIG_fail;
9997 temp3 = true;
9998 }
9999 {
10000 arg4 = wxString_in_helper(obj3);
10001 if (arg4 == NULL) SWIG_fail;
10002 temp4 = true;
10003 }
10004 {
10005 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
10006 if (!SWIG_IsOK(res5)) {
10007 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10008 }
10009 if (!argp5) {
10010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
10011 } else {
10012 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
10013 arg5 = *temp;
10014 if (SWIG_IsNewObj(res5)) delete temp;
10015 }
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
10024 {
10025 if (temp2)
10026 delete arg2;
10027 }
10028 {
10029 if (temp3)
10030 delete arg3;
10031 }
10032 {
10033 if (temp4)
10034 delete arg4;
10035 }
10036 return resultobj;
10037 fail:
10038 {
10039 if (temp2)
10040 delete arg2;
10041 }
10042 {
10043 if (temp3)
10044 delete arg3;
10045 }
10046 {
10047 if (temp4)
10048 delete arg4;
10049 }
10050 return NULL;
10051 }
10052
10053
10054 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10055 PyObject *resultobj = 0;
10056 wxFSFile *arg1 = (wxFSFile *) 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 PyObject *swig_obj[1] ;
10060
10061 if (!args) SWIG_fail;
10062 swig_obj[0] = args;
10063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
10064 if (!SWIG_IsOK(res1)) {
10065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
10066 }
10067 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10068 {
10069 PyThreadState* __tstate = wxPyBeginAllowThreads();
10070 delete arg1;
10071
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 resultobj = SWIG_Py_Void();
10076 return resultobj;
10077 fail:
10078 return NULL;
10079 }
10080
10081
10082 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10083 PyObject *resultobj = 0;
10084 wxFSFile *arg1 = (wxFSFile *) 0 ;
10085 wxInputStream *result = 0 ;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 PyObject *swig_obj[1] ;
10089
10090 if (!args) SWIG_fail;
10091 swig_obj[0] = args;
10092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10093 if (!SWIG_IsOK(res1)) {
10094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10095 }
10096 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10097 {
10098 PyThreadState* __tstate = wxPyBeginAllowThreads();
10099 result = (wxInputStream *)(arg1)->GetStream();
10100 wxPyEndAllowThreads(__tstate);
10101 if (PyErr_Occurred()) SWIG_fail;
10102 }
10103 {
10104 wxPyInputStream * _ptr = NULL;
10105
10106 if (result) {
10107 _ptr = new wxPyInputStream(result);
10108 }
10109 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
10110 }
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10118 PyObject *resultobj = 0;
10119 wxFSFile *arg1 = (wxFSFile *) 0 ;
10120 void *argp1 = 0 ;
10121 int res1 = 0 ;
10122 PyObject *swig_obj[1] ;
10123
10124 if (!args) SWIG_fail;
10125 swig_obj[0] = args;
10126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10127 if (!SWIG_IsOK(res1)) {
10128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10129 }
10130 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10131 {
10132 PyThreadState* __tstate = wxPyBeginAllowThreads();
10133 (arg1)->DetachStream();
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 resultobj = SWIG_Py_Void();
10138 return resultobj;
10139 fail:
10140 return NULL;
10141 }
10142
10143
10144 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10145 PyObject *resultobj = 0;
10146 wxFSFile *arg1 = (wxFSFile *) 0 ;
10147 wxString *result = 0 ;
10148 void *argp1 = 0 ;
10149 int res1 = 0 ;
10150 PyObject *swig_obj[1] ;
10151
10152 if (!args) SWIG_fail;
10153 swig_obj[0] = args;
10154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10155 if (!SWIG_IsOK(res1)) {
10156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10157 }
10158 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10159 {
10160 PyThreadState* __tstate = wxPyBeginAllowThreads();
10161 {
10162 wxString const &_result_ref = (arg1)->GetMimeType();
10163 result = (wxString *) &_result_ref;
10164 }
10165 wxPyEndAllowThreads(__tstate);
10166 if (PyErr_Occurred()) SWIG_fail;
10167 }
10168 {
10169 #if wxUSE_UNICODE
10170 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10171 #else
10172 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10173 #endif
10174 }
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10182 PyObject *resultobj = 0;
10183 wxFSFile *arg1 = (wxFSFile *) 0 ;
10184 wxString *result = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 PyObject *swig_obj[1] ;
10188
10189 if (!args) SWIG_fail;
10190 swig_obj[0] = args;
10191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10192 if (!SWIG_IsOK(res1)) {
10193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10194 }
10195 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10196 {
10197 PyThreadState* __tstate = wxPyBeginAllowThreads();
10198 {
10199 wxString const &_result_ref = (arg1)->GetLocation();
10200 result = (wxString *) &_result_ref;
10201 }
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 #if wxUSE_UNICODE
10207 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10208 #else
10209 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10210 #endif
10211 }
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10219 PyObject *resultobj = 0;
10220 wxFSFile *arg1 = (wxFSFile *) 0 ;
10221 wxString *result = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 PyObject *swig_obj[1] ;
10225
10226 if (!args) SWIG_fail;
10227 swig_obj[0] = args;
10228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10231 }
10232 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10233 {
10234 PyThreadState* __tstate = wxPyBeginAllowThreads();
10235 {
10236 wxString const &_result_ref = (arg1)->GetAnchor();
10237 result = (wxString *) &_result_ref;
10238 }
10239 wxPyEndAllowThreads(__tstate);
10240 if (PyErr_Occurred()) SWIG_fail;
10241 }
10242 {
10243 #if wxUSE_UNICODE
10244 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10245 #else
10246 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10247 #endif
10248 }
10249 return resultobj;
10250 fail:
10251 return NULL;
10252 }
10253
10254
10255 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10256 PyObject *resultobj = 0;
10257 wxFSFile *arg1 = (wxFSFile *) 0 ;
10258 wxDateTime result;
10259 void *argp1 = 0 ;
10260 int res1 = 0 ;
10261 PyObject *swig_obj[1] ;
10262
10263 if (!args) SWIG_fail;
10264 swig_obj[0] = args;
10265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10268 }
10269 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (arg1)->GetModificationTime();
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10277 return resultobj;
10278 fail:
10279 return NULL;
10280 }
10281
10282
10283 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10284 PyObject *obj;
10285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10286 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10287 return SWIG_Py_Void();
10288 }
10289
10290 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10291 return SWIG_Python_InitShadowInstance(args);
10292 }
10293
10294 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10295 PyObject *resultobj = 0;
10296 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10297 void *argp1 = 0 ;
10298 int res1 = 0 ;
10299 PyObject *swig_obj[1] ;
10300
10301 if (!args) SWIG_fail;
10302 swig_obj[0] = args;
10303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10304 if (!SWIG_IsOK(res1)) {
10305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10306 }
10307 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10308 {
10309 PyThreadState* __tstate = wxPyBeginAllowThreads();
10310 delete arg1;
10311
10312 wxPyEndAllowThreads(__tstate);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 resultobj = SWIG_Py_Void();
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10323 PyObject *obj;
10324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10325 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10326 return SWIG_Py_Void();
10327 }
10328
10329 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10330 PyObject *resultobj = 0;
10331 wxPyFileSystemHandler *result = 0 ;
10332
10333 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10334 {
10335 PyThreadState* __tstate = wxPyBeginAllowThreads();
10336 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10337 wxPyEndAllowThreads(__tstate);
10338 if (PyErr_Occurred()) SWIG_fail;
10339 }
10340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10341 return resultobj;
10342 fail:
10343 return NULL;
10344 }
10345
10346
10347 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10348 PyObject *resultobj = 0;
10349 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10350 PyObject *arg2 = (PyObject *) 0 ;
10351 PyObject *arg3 = (PyObject *) 0 ;
10352 void *argp1 = 0 ;
10353 int res1 = 0 ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 PyObject * obj2 = 0 ;
10357 char * kwnames[] = {
10358 (char *) "self",(char *) "self",(char *) "_class", NULL
10359 };
10360
10361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10363 if (!SWIG_IsOK(res1)) {
10364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10365 }
10366 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10367 arg2 = obj1;
10368 arg3 = obj2;
10369 {
10370 PyThreadState* __tstate = wxPyBeginAllowThreads();
10371 (arg1)->_setCallbackInfo(arg2,arg3);
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 resultobj = SWIG_Py_Void();
10376 return resultobj;
10377 fail:
10378 return NULL;
10379 }
10380
10381
10382 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10383 PyObject *resultobj = 0;
10384 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10385 wxString *arg2 = 0 ;
10386 bool result;
10387 void *argp1 = 0 ;
10388 int res1 = 0 ;
10389 bool temp2 = false ;
10390 PyObject * obj0 = 0 ;
10391 PyObject * obj1 = 0 ;
10392 char * kwnames[] = {
10393 (char *) "self",(char *) "location", NULL
10394 };
10395
10396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10398 if (!SWIG_IsOK(res1)) {
10399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10400 }
10401 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10402 {
10403 arg2 = wxString_in_helper(obj1);
10404 if (arg2 == NULL) SWIG_fail;
10405 temp2 = true;
10406 }
10407 {
10408 PyThreadState* __tstate = wxPyBeginAllowThreads();
10409 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10410 wxPyEndAllowThreads(__tstate);
10411 if (PyErr_Occurred()) SWIG_fail;
10412 }
10413 {
10414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10415 }
10416 {
10417 if (temp2)
10418 delete arg2;
10419 }
10420 return resultobj;
10421 fail:
10422 {
10423 if (temp2)
10424 delete arg2;
10425 }
10426 return NULL;
10427 }
10428
10429
10430 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj = 0;
10432 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10433 wxFileSystem *arg2 = 0 ;
10434 wxString *arg3 = 0 ;
10435 wxFSFile *result = 0 ;
10436 void *argp1 = 0 ;
10437 int res1 = 0 ;
10438 void *argp2 = 0 ;
10439 int res2 = 0 ;
10440 bool temp3 = false ;
10441 PyObject * obj0 = 0 ;
10442 PyObject * obj1 = 0 ;
10443 PyObject * obj2 = 0 ;
10444 char * kwnames[] = {
10445 (char *) "self",(char *) "fs",(char *) "location", NULL
10446 };
10447
10448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10450 if (!SWIG_IsOK(res1)) {
10451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10452 }
10453 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10455 if (!SWIG_IsOK(res2)) {
10456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10457 }
10458 if (!argp2) {
10459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10460 }
10461 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10462 {
10463 arg3 = wxString_in_helper(obj2);
10464 if (arg3 == NULL) SWIG_fail;
10465 temp3 = true;
10466 }
10467 {
10468 PyThreadState* __tstate = wxPyBeginAllowThreads();
10469 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10470 wxPyEndAllowThreads(__tstate);
10471 if (PyErr_Occurred()) SWIG_fail;
10472 }
10473 {
10474 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10475 }
10476 {
10477 if (temp3)
10478 delete arg3;
10479 }
10480 return resultobj;
10481 fail:
10482 {
10483 if (temp3)
10484 delete arg3;
10485 }
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10493 wxString *arg2 = 0 ;
10494 int arg3 = (int) 0 ;
10495 wxString result;
10496 void *argp1 = 0 ;
10497 int res1 = 0 ;
10498 bool temp2 = false ;
10499 int val3 ;
10500 int ecode3 = 0 ;
10501 PyObject * obj0 = 0 ;
10502 PyObject * obj1 = 0 ;
10503 PyObject * obj2 = 0 ;
10504 char * kwnames[] = {
10505 (char *) "self",(char *) "spec",(char *) "flags", NULL
10506 };
10507
10508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10510 if (!SWIG_IsOK(res1)) {
10511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10512 }
10513 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10514 {
10515 arg2 = wxString_in_helper(obj1);
10516 if (arg2 == NULL) SWIG_fail;
10517 temp2 = true;
10518 }
10519 if (obj2) {
10520 ecode3 = SWIG_AsVal_int(obj2, &val3);
10521 if (!SWIG_IsOK(ecode3)) {
10522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10523 }
10524 arg3 = static_cast< int >(val3);
10525 }
10526 {
10527 PyThreadState* __tstate = wxPyBeginAllowThreads();
10528 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10529 wxPyEndAllowThreads(__tstate);
10530 if (PyErr_Occurred()) SWIG_fail;
10531 }
10532 {
10533 #if wxUSE_UNICODE
10534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10535 #else
10536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10537 #endif
10538 }
10539 {
10540 if (temp2)
10541 delete arg2;
10542 }
10543 return resultobj;
10544 fail:
10545 {
10546 if (temp2)
10547 delete arg2;
10548 }
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10554 PyObject *resultobj = 0;
10555 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10556 wxString result;
10557 void *argp1 = 0 ;
10558 int res1 = 0 ;
10559 PyObject *swig_obj[1] ;
10560
10561 if (!args) SWIG_fail;
10562 swig_obj[0] = args;
10563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10564 if (!SWIG_IsOK(res1)) {
10565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10566 }
10567 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (arg1)->FindNext();
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 {
10575 #if wxUSE_UNICODE
10576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10577 #else
10578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10579 #endif
10580 }
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj = 0;
10589 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10590 wxString *arg2 = 0 ;
10591 wxString result;
10592 void *argp1 = 0 ;
10593 int res1 = 0 ;
10594 bool temp2 = false ;
10595 PyObject * obj0 = 0 ;
10596 PyObject * obj1 = 0 ;
10597 char * kwnames[] = {
10598 (char *) "self",(char *) "location", NULL
10599 };
10600
10601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10603 if (!SWIG_IsOK(res1)) {
10604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10605 }
10606 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10607 {
10608 arg2 = wxString_in_helper(obj1);
10609 if (arg2 == NULL) SWIG_fail;
10610 temp2 = true;
10611 }
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (arg1)->GetProtocol((wxString const &)*arg2);
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 #if wxUSE_UNICODE
10620 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10621 #else
10622 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10623 #endif
10624 }
10625 {
10626 if (temp2)
10627 delete arg2;
10628 }
10629 return resultobj;
10630 fail:
10631 {
10632 if (temp2)
10633 delete arg2;
10634 }
10635 return NULL;
10636 }
10637
10638
10639 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj = 0;
10641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10642 wxString *arg2 = 0 ;
10643 wxString result;
10644 void *argp1 = 0 ;
10645 int res1 = 0 ;
10646 bool temp2 = false ;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 char * kwnames[] = {
10650 (char *) "self",(char *) "location", NULL
10651 };
10652
10653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10655 if (!SWIG_IsOK(res1)) {
10656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10657 }
10658 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10659 {
10660 arg2 = wxString_in_helper(obj1);
10661 if (arg2 == NULL) SWIG_fail;
10662 temp2 = true;
10663 }
10664 {
10665 PyThreadState* __tstate = wxPyBeginAllowThreads();
10666 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10667 wxPyEndAllowThreads(__tstate);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 {
10671 #if wxUSE_UNICODE
10672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10673 #else
10674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10675 #endif
10676 }
10677 {
10678 if (temp2)
10679 delete arg2;
10680 }
10681 return resultobj;
10682 fail:
10683 {
10684 if (temp2)
10685 delete arg2;
10686 }
10687 return NULL;
10688 }
10689
10690
10691 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10692 PyObject *resultobj = 0;
10693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10694 wxString *arg2 = 0 ;
10695 wxString result;
10696 void *argp1 = 0 ;
10697 int res1 = 0 ;
10698 bool temp2 = false ;
10699 PyObject * obj0 = 0 ;
10700 PyObject * obj1 = 0 ;
10701 char * kwnames[] = {
10702 (char *) "self",(char *) "location", NULL
10703 };
10704
10705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10707 if (!SWIG_IsOK(res1)) {
10708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10709 }
10710 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10711 {
10712 arg2 = wxString_in_helper(obj1);
10713 if (arg2 == NULL) SWIG_fail;
10714 temp2 = true;
10715 }
10716 {
10717 PyThreadState* __tstate = wxPyBeginAllowThreads();
10718 result = (arg1)->GetAnchor((wxString const &)*arg2);
10719 wxPyEndAllowThreads(__tstate);
10720 if (PyErr_Occurred()) SWIG_fail;
10721 }
10722 {
10723 #if wxUSE_UNICODE
10724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10725 #else
10726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10727 #endif
10728 }
10729 {
10730 if (temp2)
10731 delete arg2;
10732 }
10733 return resultobj;
10734 fail:
10735 {
10736 if (temp2)
10737 delete arg2;
10738 }
10739 return NULL;
10740 }
10741
10742
10743 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj = 0;
10745 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10746 wxString *arg2 = 0 ;
10747 wxString result;
10748 void *argp1 = 0 ;
10749 int res1 = 0 ;
10750 bool temp2 = false ;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 char * kwnames[] = {
10754 (char *) "self",(char *) "location", NULL
10755 };
10756
10757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10759 if (!SWIG_IsOK(res1)) {
10760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10761 }
10762 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10763 {
10764 arg2 = wxString_in_helper(obj1);
10765 if (arg2 == NULL) SWIG_fail;
10766 temp2 = true;
10767 }
10768 {
10769 PyThreadState* __tstate = wxPyBeginAllowThreads();
10770 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 #if wxUSE_UNICODE
10776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10777 #else
10778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10779 #endif
10780 }
10781 {
10782 if (temp2)
10783 delete arg2;
10784 }
10785 return resultobj;
10786 fail:
10787 {
10788 if (temp2)
10789 delete arg2;
10790 }
10791 return NULL;
10792 }
10793
10794
10795 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj = 0;
10797 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10798 wxString *arg2 = 0 ;
10799 wxString result;
10800 void *argp1 = 0 ;
10801 int res1 = 0 ;
10802 bool temp2 = false ;
10803 PyObject * obj0 = 0 ;
10804 PyObject * obj1 = 0 ;
10805 char * kwnames[] = {
10806 (char *) "self",(char *) "location", NULL
10807 };
10808
10809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10811 if (!SWIG_IsOK(res1)) {
10812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10813 }
10814 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10815 {
10816 arg2 = wxString_in_helper(obj1);
10817 if (arg2 == NULL) SWIG_fail;
10818 temp2 = true;
10819 }
10820 {
10821 PyThreadState* __tstate = wxPyBeginAllowThreads();
10822 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10823 wxPyEndAllowThreads(__tstate);
10824 if (PyErr_Occurred()) SWIG_fail;
10825 }
10826 {
10827 #if wxUSE_UNICODE
10828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10829 #else
10830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10831 #endif
10832 }
10833 {
10834 if (temp2)
10835 delete arg2;
10836 }
10837 return resultobj;
10838 fail:
10839 {
10840 if (temp2)
10841 delete arg2;
10842 }
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10848 PyObject *obj;
10849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10851 return SWIG_Py_Void();
10852 }
10853
10854 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10855 return SWIG_Python_InitShadowInstance(args);
10856 }
10857
10858 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10859 PyObject *resultobj = 0;
10860 wxFileSystem *result = 0 ;
10861
10862 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = (wxFileSystem *)new wxFileSystem();
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10879 PyObject *resultobj = 0;
10880 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 PyObject *swig_obj[1] ;
10884
10885 if (!args) SWIG_fail;
10886 swig_obj[0] = args;
10887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10888 if (!SWIG_IsOK(res1)) {
10889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10890 }
10891 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 delete arg1;
10895
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_Py_Void();
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10909 wxString *arg2 = 0 ;
10910 bool arg3 = (bool) false ;
10911 void *argp1 = 0 ;
10912 int res1 = 0 ;
10913 bool temp2 = false ;
10914 bool val3 ;
10915 int ecode3 = 0 ;
10916 PyObject * obj0 = 0 ;
10917 PyObject * obj1 = 0 ;
10918 PyObject * obj2 = 0 ;
10919 char * kwnames[] = {
10920 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10921 };
10922
10923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10925 if (!SWIG_IsOK(res1)) {
10926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10927 }
10928 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10929 {
10930 arg2 = wxString_in_helper(obj1);
10931 if (arg2 == NULL) SWIG_fail;
10932 temp2 = true;
10933 }
10934 if (obj2) {
10935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10936 if (!SWIG_IsOK(ecode3)) {
10937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10938 }
10939 arg3 = static_cast< bool >(val3);
10940 }
10941 {
10942 PyThreadState* __tstate = wxPyBeginAllowThreads();
10943 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10944 wxPyEndAllowThreads(__tstate);
10945 if (PyErr_Occurred()) SWIG_fail;
10946 }
10947 resultobj = SWIG_Py_Void();
10948 {
10949 if (temp2)
10950 delete arg2;
10951 }
10952 return resultobj;
10953 fail:
10954 {
10955 if (temp2)
10956 delete arg2;
10957 }
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10963 PyObject *resultobj = 0;
10964 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10965 wxString result;
10966 void *argp1 = 0 ;
10967 int res1 = 0 ;
10968 PyObject *swig_obj[1] ;
10969
10970 if (!args) SWIG_fail;
10971 swig_obj[0] = args;
10972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10973 if (!SWIG_IsOK(res1)) {
10974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10975 }
10976 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10977 {
10978 PyThreadState* __tstate = wxPyBeginAllowThreads();
10979 result = (arg1)->GetPath();
10980 wxPyEndAllowThreads(__tstate);
10981 if (PyErr_Occurred()) SWIG_fail;
10982 }
10983 {
10984 #if wxUSE_UNICODE
10985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10986 #else
10987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10988 #endif
10989 }
10990 return resultobj;
10991 fail:
10992 return NULL;
10993 }
10994
10995
10996 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10997 PyObject *resultobj = 0;
10998 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10999 wxString *arg2 = 0 ;
11000 wxFSFile *result = 0 ;
11001 void *argp1 = 0 ;
11002 int res1 = 0 ;
11003 bool temp2 = false ;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 char * kwnames[] = {
11007 (char *) "self",(char *) "location", NULL
11008 };
11009
11010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
11011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11012 if (!SWIG_IsOK(res1)) {
11013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11014 }
11015 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11016 {
11017 arg2 = wxString_in_helper(obj1);
11018 if (arg2 == NULL) SWIG_fail;
11019 temp2 = true;
11020 }
11021 {
11022 PyThreadState* __tstate = wxPyBeginAllowThreads();
11023 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
11024 wxPyEndAllowThreads(__tstate);
11025 if (PyErr_Occurred()) SWIG_fail;
11026 }
11027 {
11028 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11029 }
11030 {
11031 if (temp2)
11032 delete arg2;
11033 }
11034 return resultobj;
11035 fail:
11036 {
11037 if (temp2)
11038 delete arg2;
11039 }
11040 return NULL;
11041 }
11042
11043
11044 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11045 PyObject *resultobj = 0;
11046 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11047 wxString *arg2 = 0 ;
11048 int arg3 = (int) 0 ;
11049 wxString result;
11050 void *argp1 = 0 ;
11051 int res1 = 0 ;
11052 bool temp2 = false ;
11053 int val3 ;
11054 int ecode3 = 0 ;
11055 PyObject * obj0 = 0 ;
11056 PyObject * obj1 = 0 ;
11057 PyObject * obj2 = 0 ;
11058 char * kwnames[] = {
11059 (char *) "self",(char *) "spec",(char *) "flags", NULL
11060 };
11061
11062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11066 }
11067 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11068 {
11069 arg2 = wxString_in_helper(obj1);
11070 if (arg2 == NULL) SWIG_fail;
11071 temp2 = true;
11072 }
11073 if (obj2) {
11074 ecode3 = SWIG_AsVal_int(obj2, &val3);
11075 if (!SWIG_IsOK(ecode3)) {
11076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
11077 }
11078 arg3 = static_cast< int >(val3);
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 {
11087 #if wxUSE_UNICODE
11088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11089 #else
11090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11091 #endif
11092 }
11093 {
11094 if (temp2)
11095 delete arg2;
11096 }
11097 return resultobj;
11098 fail:
11099 {
11100 if (temp2)
11101 delete arg2;
11102 }
11103 return NULL;
11104 }
11105
11106
11107 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11108 PyObject *resultobj = 0;
11109 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
11110 wxString result;
11111 void *argp1 = 0 ;
11112 int res1 = 0 ;
11113 PyObject *swig_obj[1] ;
11114
11115 if (!args) SWIG_fail;
11116 swig_obj[0] = args;
11117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
11118 if (!SWIG_IsOK(res1)) {
11119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
11120 }
11121 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
11122 {
11123 PyThreadState* __tstate = wxPyBeginAllowThreads();
11124 result = (arg1)->FindNext();
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 #if wxUSE_UNICODE
11130 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11131 #else
11132 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11133 #endif
11134 }
11135 return resultobj;
11136 fail:
11137 return NULL;
11138 }
11139
11140
11141 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11142 PyObject *resultobj = 0;
11143 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11144 int res1 = 0 ;
11145 PyObject * obj0 = 0 ;
11146 char * kwnames[] = {
11147 (char *) "handler", NULL
11148 };
11149
11150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11151 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11152 if (!SWIG_IsOK(res1)) {
11153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11154 }
11155 {
11156 PyThreadState* __tstate = wxPyBeginAllowThreads();
11157 wxFileSystem::AddHandler(arg1);
11158 wxPyEndAllowThreads(__tstate);
11159 if (PyErr_Occurred()) SWIG_fail;
11160 }
11161 resultobj = SWIG_Py_Void();
11162 return resultobj;
11163 fail:
11164 return NULL;
11165 }
11166
11167
11168 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11169 PyObject *resultobj = 0;
11170 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11171 wxFileSystemHandler *result = 0 ;
11172 void *argp1 = 0 ;
11173 int res1 = 0 ;
11174 PyObject * obj0 = 0 ;
11175 char * kwnames[] = {
11176 (char *) "handler", NULL
11177 };
11178
11179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11181 if (!SWIG_IsOK(res1)) {
11182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11183 }
11184 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200
11201 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11202 {
11203 PyThreadState* __tstate = wxPyBeginAllowThreads();
11204 wxFileSystem::CleanUpHandlers();
11205 wxPyEndAllowThreads(__tstate);
11206 if (PyErr_Occurred()) SWIG_fail;
11207 }
11208 resultobj = SWIG_Py_Void();
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj = 0;
11217 wxString *arg1 = 0 ;
11218 wxString result;
11219 bool temp1 = false ;
11220 PyObject * obj0 = 0 ;
11221 char * kwnames[] = {
11222 (char *) "filename", NULL
11223 };
11224
11225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11226 {
11227 arg1 = wxString_in_helper(obj0);
11228 if (arg1 == NULL) SWIG_fail;
11229 temp1 = true;
11230 }
11231 {
11232 PyThreadState* __tstate = wxPyBeginAllowThreads();
11233 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11234 wxPyEndAllowThreads(__tstate);
11235 if (PyErr_Occurred()) SWIG_fail;
11236 }
11237 {
11238 #if wxUSE_UNICODE
11239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11240 #else
11241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11242 #endif
11243 }
11244 {
11245 if (temp1)
11246 delete arg1;
11247 }
11248 return resultobj;
11249 fail:
11250 {
11251 if (temp1)
11252 delete arg1;
11253 }
11254 return NULL;
11255 }
11256
11257
11258 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11259 PyObject *resultobj = 0;
11260 wxString *arg1 = 0 ;
11261 wxString result;
11262 bool temp1 = false ;
11263 PyObject * obj0 = 0 ;
11264 char * kwnames[] = {
11265 (char *) "url", NULL
11266 };
11267
11268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11269 {
11270 arg1 = wxString_in_helper(obj0);
11271 if (arg1 == NULL) SWIG_fail;
11272 temp1 = true;
11273 }
11274 {
11275 PyThreadState* __tstate = wxPyBeginAllowThreads();
11276 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11277 wxPyEndAllowThreads(__tstate);
11278 if (PyErr_Occurred()) SWIG_fail;
11279 }
11280 {
11281 #if wxUSE_UNICODE
11282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11283 #else
11284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11285 #endif
11286 }
11287 {
11288 if (temp1)
11289 delete arg1;
11290 }
11291 return resultobj;
11292 fail:
11293 {
11294 if (temp1)
11295 delete arg1;
11296 }
11297 return NULL;
11298 }
11299
11300
11301 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11302 PyObject *obj;
11303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11304 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11305 return SWIG_Py_Void();
11306 }
11307
11308 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11309 return SWIG_Python_InitShadowInstance(args);
11310 }
11311
11312 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11313 PyObject *resultobj = 0;
11314 wxInternetFSHandler *result = 0 ;
11315
11316 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11320 wxPyEndAllowThreads(__tstate);
11321 if (PyErr_Occurred()) SWIG_fail;
11322 }
11323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj = 0;
11332 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11333 wxString *arg2 = 0 ;
11334 bool result;
11335 void *argp1 = 0 ;
11336 int res1 = 0 ;
11337 bool temp2 = false ;
11338 PyObject * obj0 = 0 ;
11339 PyObject * obj1 = 0 ;
11340 char * kwnames[] = {
11341 (char *) "self",(char *) "location", NULL
11342 };
11343
11344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11346 if (!SWIG_IsOK(res1)) {
11347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11348 }
11349 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11350 {
11351 arg2 = wxString_in_helper(obj1);
11352 if (arg2 == NULL) SWIG_fail;
11353 temp2 = true;
11354 }
11355 {
11356 PyThreadState* __tstate = wxPyBeginAllowThreads();
11357 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11358 wxPyEndAllowThreads(__tstate);
11359 if (PyErr_Occurred()) SWIG_fail;
11360 }
11361 {
11362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11363 }
11364 {
11365 if (temp2)
11366 delete arg2;
11367 }
11368 return resultobj;
11369 fail:
11370 {
11371 if (temp2)
11372 delete arg2;
11373 }
11374 return NULL;
11375 }
11376
11377
11378 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11379 PyObject *resultobj = 0;
11380 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11381 wxFileSystem *arg2 = 0 ;
11382 wxString *arg3 = 0 ;
11383 wxFSFile *result = 0 ;
11384 void *argp1 = 0 ;
11385 int res1 = 0 ;
11386 void *argp2 = 0 ;
11387 int res2 = 0 ;
11388 bool temp3 = false ;
11389 PyObject * obj0 = 0 ;
11390 PyObject * obj1 = 0 ;
11391 PyObject * obj2 = 0 ;
11392 char * kwnames[] = {
11393 (char *) "self",(char *) "fs",(char *) "location", NULL
11394 };
11395
11396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11398 if (!SWIG_IsOK(res1)) {
11399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11400 }
11401 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11402 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11403 if (!SWIG_IsOK(res2)) {
11404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11405 }
11406 if (!argp2) {
11407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11408 }
11409 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11410 {
11411 arg3 = wxString_in_helper(obj2);
11412 if (arg3 == NULL) SWIG_fail;
11413 temp3 = true;
11414 }
11415 {
11416 PyThreadState* __tstate = wxPyBeginAllowThreads();
11417 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11418 wxPyEndAllowThreads(__tstate);
11419 if (PyErr_Occurred()) SWIG_fail;
11420 }
11421 {
11422 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11423 }
11424 {
11425 if (temp3)
11426 delete arg3;
11427 }
11428 return resultobj;
11429 fail:
11430 {
11431 if (temp3)
11432 delete arg3;
11433 }
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11439 PyObject *obj;
11440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11441 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11442 return SWIG_Py_Void();
11443 }
11444
11445 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11446 return SWIG_Python_InitShadowInstance(args);
11447 }
11448
11449 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11450 PyObject *resultobj = 0;
11451 wxZipFSHandler *result = 0 ;
11452
11453 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11454 {
11455 PyThreadState* __tstate = wxPyBeginAllowThreads();
11456 result = (wxZipFSHandler *)new wxZipFSHandler();
11457 wxPyEndAllowThreads(__tstate);
11458 if (PyErr_Occurred()) SWIG_fail;
11459 }
11460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11461 return resultobj;
11462 fail:
11463 return NULL;
11464 }
11465
11466
11467 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11468 PyObject *resultobj = 0;
11469 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11470 wxString *arg2 = 0 ;
11471 bool result;
11472 void *argp1 = 0 ;
11473 int res1 = 0 ;
11474 bool temp2 = false ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 char * kwnames[] = {
11478 (char *) "self",(char *) "location", NULL
11479 };
11480
11481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11483 if (!SWIG_IsOK(res1)) {
11484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11485 }
11486 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11487 {
11488 arg2 = wxString_in_helper(obj1);
11489 if (arg2 == NULL) SWIG_fail;
11490 temp2 = true;
11491 }
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11495 wxPyEndAllowThreads(__tstate);
11496 if (PyErr_Occurred()) SWIG_fail;
11497 }
11498 {
11499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11500 }
11501 {
11502 if (temp2)
11503 delete arg2;
11504 }
11505 return resultobj;
11506 fail:
11507 {
11508 if (temp2)
11509 delete arg2;
11510 }
11511 return NULL;
11512 }
11513
11514
11515 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11516 PyObject *resultobj = 0;
11517 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11518 wxFileSystem *arg2 = 0 ;
11519 wxString *arg3 = 0 ;
11520 wxFSFile *result = 0 ;
11521 void *argp1 = 0 ;
11522 int res1 = 0 ;
11523 void *argp2 = 0 ;
11524 int res2 = 0 ;
11525 bool temp3 = false ;
11526 PyObject * obj0 = 0 ;
11527 PyObject * obj1 = 0 ;
11528 PyObject * obj2 = 0 ;
11529 char * kwnames[] = {
11530 (char *) "self",(char *) "fs",(char *) "location", NULL
11531 };
11532
11533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11535 if (!SWIG_IsOK(res1)) {
11536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11537 }
11538 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11540 if (!SWIG_IsOK(res2)) {
11541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11542 }
11543 if (!argp2) {
11544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11545 }
11546 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11547 {
11548 arg3 = wxString_in_helper(obj2);
11549 if (arg3 == NULL) SWIG_fail;
11550 temp3 = true;
11551 }
11552 {
11553 PyThreadState* __tstate = wxPyBeginAllowThreads();
11554 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11555 wxPyEndAllowThreads(__tstate);
11556 if (PyErr_Occurred()) SWIG_fail;
11557 }
11558 {
11559 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11560 }
11561 {
11562 if (temp3)
11563 delete arg3;
11564 }
11565 return resultobj;
11566 fail:
11567 {
11568 if (temp3)
11569 delete arg3;
11570 }
11571 return NULL;
11572 }
11573
11574
11575 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11576 PyObject *resultobj = 0;
11577 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11578 wxString *arg2 = 0 ;
11579 int arg3 = (int) 0 ;
11580 wxString result;
11581 void *argp1 = 0 ;
11582 int res1 = 0 ;
11583 bool temp2 = false ;
11584 int val3 ;
11585 int ecode3 = 0 ;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char * kwnames[] = {
11590 (char *) "self",(char *) "spec",(char *) "flags", NULL
11591 };
11592
11593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11595 if (!SWIG_IsOK(res1)) {
11596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11597 }
11598 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11599 {
11600 arg2 = wxString_in_helper(obj1);
11601 if (arg2 == NULL) SWIG_fail;
11602 temp2 = true;
11603 }
11604 if (obj2) {
11605 ecode3 = SWIG_AsVal_int(obj2, &val3);
11606 if (!SWIG_IsOK(ecode3)) {
11607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11608 }
11609 arg3 = static_cast< int >(val3);
11610 }
11611 {
11612 PyThreadState* __tstate = wxPyBeginAllowThreads();
11613 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11614 wxPyEndAllowThreads(__tstate);
11615 if (PyErr_Occurred()) SWIG_fail;
11616 }
11617 {
11618 #if wxUSE_UNICODE
11619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11620 #else
11621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11622 #endif
11623 }
11624 {
11625 if (temp2)
11626 delete arg2;
11627 }
11628 return resultobj;
11629 fail:
11630 {
11631 if (temp2)
11632 delete arg2;
11633 }
11634 return NULL;
11635 }
11636
11637
11638 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11639 PyObject *resultobj = 0;
11640 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11641 wxString result;
11642 void *argp1 = 0 ;
11643 int res1 = 0 ;
11644 PyObject *swig_obj[1] ;
11645
11646 if (!args) SWIG_fail;
11647 swig_obj[0] = args;
11648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11651 }
11652 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (arg1)->FindNext();
11656 wxPyEndAllowThreads(__tstate);
11657 if (PyErr_Occurred()) SWIG_fail;
11658 }
11659 {
11660 #if wxUSE_UNICODE
11661 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11662 #else
11663 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11664 #endif
11665 }
11666 return resultobj;
11667 fail:
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11673 PyObject *obj;
11674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11675 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11676 return SWIG_Py_Void();
11677 }
11678
11679 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11680 return SWIG_Python_InitShadowInstance(args);
11681 }
11682
11683 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11684 PyObject *resultobj = 0;
11685 wxString *arg1 = 0 ;
11686 wxImage *arg2 = 0 ;
11687 long arg3 ;
11688 bool temp1 = false ;
11689 void *argp2 = 0 ;
11690 int res2 = 0 ;
11691 long val3 ;
11692 int ecode3 = 0 ;
11693 PyObject * obj0 = 0 ;
11694 PyObject * obj1 = 0 ;
11695 PyObject * obj2 = 0 ;
11696 char * kwnames[] = {
11697 (char *) "filename",(char *) "image",(char *) "type", NULL
11698 };
11699
11700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11701 {
11702 arg1 = wxString_in_helper(obj0);
11703 if (arg1 == NULL) SWIG_fail;
11704 temp1 = true;
11705 }
11706 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11707 if (!SWIG_IsOK(res2)) {
11708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11709 }
11710 if (!argp2) {
11711 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11712 }
11713 arg2 = reinterpret_cast< wxImage * >(argp2);
11714 ecode3 = SWIG_AsVal_long(obj2, &val3);
11715 if (!SWIG_IsOK(ecode3)) {
11716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11717 }
11718 arg3 = static_cast< long >(val3);
11719 {
11720 PyThreadState* __tstate = wxPyBeginAllowThreads();
11721 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 resultobj = SWIG_Py_Void();
11726 {
11727 if (temp1)
11728 delete arg1;
11729 }
11730 return resultobj;
11731 fail:
11732 {
11733 if (temp1)
11734 delete arg1;
11735 }
11736 return NULL;
11737 }
11738
11739
11740 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11741 PyObject *resultobj = 0;
11742 wxString *arg1 = 0 ;
11743 wxBitmap *arg2 = 0 ;
11744 long arg3 ;
11745 bool temp1 = false ;
11746 void *argp2 = 0 ;
11747 int res2 = 0 ;
11748 long val3 ;
11749 int ecode3 = 0 ;
11750 PyObject * obj0 = 0 ;
11751 PyObject * obj1 = 0 ;
11752 PyObject * obj2 = 0 ;
11753 char * kwnames[] = {
11754 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11755 };
11756
11757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11758 {
11759 arg1 = wxString_in_helper(obj0);
11760 if (arg1 == NULL) SWIG_fail;
11761 temp1 = true;
11762 }
11763 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11764 if (!SWIG_IsOK(res2)) {
11765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11766 }
11767 if (!argp2) {
11768 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11769 }
11770 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11771 ecode3 = SWIG_AsVal_long(obj2, &val3);
11772 if (!SWIG_IsOK(ecode3)) {
11773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11774 }
11775 arg3 = static_cast< long >(val3);
11776 {
11777 PyThreadState* __tstate = wxPyBeginAllowThreads();
11778 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 resultobj = SWIG_Py_Void();
11783 {
11784 if (temp1)
11785 delete arg1;
11786 }
11787 return resultobj;
11788 fail:
11789 {
11790 if (temp1)
11791 delete arg1;
11792 }
11793 return NULL;
11794 }
11795
11796
11797 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11798 PyObject *resultobj = 0;
11799 wxString *arg1 = 0 ;
11800 PyObject *arg2 = (PyObject *) 0 ;
11801 bool temp1 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "filename",(char *) "data", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11809 {
11810 arg1 = wxString_in_helper(obj0);
11811 if (arg1 == NULL) SWIG_fail;
11812 temp1 = true;
11813 }
11814 arg2 = obj1;
11815 {
11816 PyThreadState* __tstate = wxPyBeginAllowThreads();
11817 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11818 wxPyEndAllowThreads(__tstate);
11819 if (PyErr_Occurred()) SWIG_fail;
11820 }
11821 resultobj = SWIG_Py_Void();
11822 {
11823 if (temp1)
11824 delete arg1;
11825 }
11826 return resultobj;
11827 fail:
11828 {
11829 if (temp1)
11830 delete arg1;
11831 }
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11837 PyObject *resultobj = 0;
11838 wxMemoryFSHandler *result = 0 ;
11839
11840 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11841 {
11842 PyThreadState* __tstate = wxPyBeginAllowThreads();
11843 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11848 return resultobj;
11849 fail:
11850 return NULL;
11851 }
11852
11853
11854 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11855 PyObject *resultobj = 0;
11856 wxString *arg1 = 0 ;
11857 bool temp1 = false ;
11858 PyObject * obj0 = 0 ;
11859 char * kwnames[] = {
11860 (char *) "filename", NULL
11861 };
11862
11863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11864 {
11865 arg1 = wxString_in_helper(obj0);
11866 if (arg1 == NULL) SWIG_fail;
11867 temp1 = true;
11868 }
11869 {
11870 PyThreadState* __tstate = wxPyBeginAllowThreads();
11871 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 resultobj = SWIG_Py_Void();
11876 {
11877 if (temp1)
11878 delete arg1;
11879 }
11880 return resultobj;
11881 fail:
11882 {
11883 if (temp1)
11884 delete arg1;
11885 }
11886 return NULL;
11887 }
11888
11889
11890 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = 0;
11892 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11893 wxString *arg2 = 0 ;
11894 bool result;
11895 void *argp1 = 0 ;
11896 int res1 = 0 ;
11897 bool temp2 = false ;
11898 PyObject * obj0 = 0 ;
11899 PyObject * obj1 = 0 ;
11900 char * kwnames[] = {
11901 (char *) "self",(char *) "location", NULL
11902 };
11903
11904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11906 if (!SWIG_IsOK(res1)) {
11907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11908 }
11909 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11910 {
11911 arg2 = wxString_in_helper(obj1);
11912 if (arg2 == NULL) SWIG_fail;
11913 temp2 = true;
11914 }
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11923 }
11924 {
11925 if (temp2)
11926 delete arg2;
11927 }
11928 return resultobj;
11929 fail:
11930 {
11931 if (temp2)
11932 delete arg2;
11933 }
11934 return NULL;
11935 }
11936
11937
11938 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11939 PyObject *resultobj = 0;
11940 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11941 wxFileSystem *arg2 = 0 ;
11942 wxString *arg3 = 0 ;
11943 wxFSFile *result = 0 ;
11944 void *argp1 = 0 ;
11945 int res1 = 0 ;
11946 void *argp2 = 0 ;
11947 int res2 = 0 ;
11948 bool temp3 = false ;
11949 PyObject * obj0 = 0 ;
11950 PyObject * obj1 = 0 ;
11951 PyObject * obj2 = 0 ;
11952 char * kwnames[] = {
11953 (char *) "self",(char *) "fs",(char *) "location", NULL
11954 };
11955
11956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11958 if (!SWIG_IsOK(res1)) {
11959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11960 }
11961 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11962 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11963 if (!SWIG_IsOK(res2)) {
11964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11965 }
11966 if (!argp2) {
11967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11968 }
11969 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11970 {
11971 arg3 = wxString_in_helper(obj2);
11972 if (arg3 == NULL) SWIG_fail;
11973 temp3 = true;
11974 }
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 {
11982 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11983 }
11984 {
11985 if (temp3)
11986 delete arg3;
11987 }
11988 return resultobj;
11989 fail:
11990 {
11991 if (temp3)
11992 delete arg3;
11993 }
11994 return NULL;
11995 }
11996
11997
11998 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11999 PyObject *resultobj = 0;
12000 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12001 wxString *arg2 = 0 ;
12002 int arg3 = (int) 0 ;
12003 wxString result;
12004 void *argp1 = 0 ;
12005 int res1 = 0 ;
12006 bool temp2 = false ;
12007 int val3 ;
12008 int ecode3 = 0 ;
12009 PyObject * obj0 = 0 ;
12010 PyObject * obj1 = 0 ;
12011 PyObject * obj2 = 0 ;
12012 char * kwnames[] = {
12013 (char *) "self",(char *) "spec",(char *) "flags", NULL
12014 };
12015
12016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12018 if (!SWIG_IsOK(res1)) {
12019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12020 }
12021 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12022 {
12023 arg2 = wxString_in_helper(obj1);
12024 if (arg2 == NULL) SWIG_fail;
12025 temp2 = true;
12026 }
12027 if (obj2) {
12028 ecode3 = SWIG_AsVal_int(obj2, &val3);
12029 if (!SWIG_IsOK(ecode3)) {
12030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12031 }
12032 arg3 = static_cast< int >(val3);
12033 }
12034 {
12035 PyThreadState* __tstate = wxPyBeginAllowThreads();
12036 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 #if wxUSE_UNICODE
12042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12043 #else
12044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12045 #endif
12046 }
12047 {
12048 if (temp2)
12049 delete arg2;
12050 }
12051 return resultobj;
12052 fail:
12053 {
12054 if (temp2)
12055 delete arg2;
12056 }
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12062 PyObject *resultobj = 0;
12063 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
12064 wxString result;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 PyObject *swig_obj[1] ;
12068
12069 if (!args) SWIG_fail;
12070 swig_obj[0] = args;
12071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
12074 }
12075 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 result = (arg1)->FindNext();
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 {
12083 #if wxUSE_UNICODE
12084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12085 #else
12086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12087 #endif
12088 }
12089 return resultobj;
12090 fail:
12091 return NULL;
12092 }
12093
12094
12095 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12096 PyObject *obj;
12097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12098 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
12099 return SWIG_Py_Void();
12100 }
12101
12102 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12103 return SWIG_Python_InitShadowInstance(args);
12104 }
12105
12106 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 PyObject *resultobj = 0;
12108 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12109 wxString result;
12110 void *argp1 = 0 ;
12111 int res1 = 0 ;
12112 PyObject *swig_obj[1] ;
12113
12114 if (!args) SWIG_fail;
12115 swig_obj[0] = args;
12116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12117 if (!SWIG_IsOK(res1)) {
12118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12119 }
12120 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12121 {
12122 PyThreadState* __tstate = wxPyBeginAllowThreads();
12123 result = (arg1)->GetName();
12124 wxPyEndAllowThreads(__tstate);
12125 if (PyErr_Occurred()) SWIG_fail;
12126 }
12127 {
12128 #if wxUSE_UNICODE
12129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12130 #else
12131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12132 #endif
12133 }
12134 return resultobj;
12135 fail:
12136 return NULL;
12137 }
12138
12139
12140 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12141 PyObject *resultobj = 0;
12142 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12143 wxString result;
12144 void *argp1 = 0 ;
12145 int res1 = 0 ;
12146 PyObject *swig_obj[1] ;
12147
12148 if (!args) SWIG_fail;
12149 swig_obj[0] = args;
12150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12151 if (!SWIG_IsOK(res1)) {
12152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12153 }
12154 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (arg1)->GetExtension();
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 {
12162 #if wxUSE_UNICODE
12163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12164 #else
12165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12166 #endif
12167 }
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12175 PyObject *resultobj = 0;
12176 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12177 long result;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 PyObject *swig_obj[1] ;
12181
12182 if (!args) SWIG_fail;
12183 swig_obj[0] = args;
12184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12185 if (!SWIG_IsOK(res1)) {
12186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12187 }
12188 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 result = (long)(arg1)->GetType();
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_From_long(static_cast< long >(result));
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *resultobj = 0;
12204 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12205 wxString result;
12206 void *argp1 = 0 ;
12207 int res1 = 0 ;
12208 PyObject *swig_obj[1] ;
12209
12210 if (!args) SWIG_fail;
12211 swig_obj[0] = args;
12212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12213 if (!SWIG_IsOK(res1)) {
12214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12215 }
12216 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12217 {
12218 PyThreadState* __tstate = wxPyBeginAllowThreads();
12219 result = (arg1)->GetMimeType();
12220 wxPyEndAllowThreads(__tstate);
12221 if (PyErr_Occurred()) SWIG_fail;
12222 }
12223 {
12224 #if wxUSE_UNICODE
12225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12226 #else
12227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12228 #endif
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj = 0;
12238 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12239 wxString *arg2 = 0 ;
12240 bool result;
12241 void *argp1 = 0 ;
12242 int res1 = 0 ;
12243 bool temp2 = false ;
12244 PyObject * obj0 = 0 ;
12245 PyObject * obj1 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "self",(char *) "name", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12252 if (!SWIG_IsOK(res1)) {
12253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12254 }
12255 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12256 {
12257 arg2 = wxString_in_helper(obj1);
12258 if (arg2 == NULL) SWIG_fail;
12259 temp2 = true;
12260 }
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 {
12268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12269 }
12270 {
12271 if (temp2)
12272 delete arg2;
12273 }
12274 return resultobj;
12275 fail:
12276 {
12277 if (temp2)
12278 delete arg2;
12279 }
12280 return NULL;
12281 }
12282
12283
12284 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12285 PyObject *resultobj = 0;
12286 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12287 wxInputStream *arg2 = 0 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 wxPyInputStream *temp2 ;
12292 bool created2 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "stream", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12303 }
12304 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12305 {
12306 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12307 arg2 = temp2->m_wxis;
12308 created2 = false;
12309 } else {
12310 PyErr_Clear(); // clear the failure of the wxPyConvert above
12311 arg2 = wxPyCBInputStream_create(obj1, false);
12312 if (arg2 == NULL) {
12313 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12314 SWIG_fail;
12315 }
12316 created2 = true;
12317 }
12318 }
12319 {
12320 PyThreadState* __tstate = wxPyBeginAllowThreads();
12321 result = (bool)(arg1)->CanRead(*arg2);
12322 wxPyEndAllowThreads(__tstate);
12323 if (PyErr_Occurred()) SWIG_fail;
12324 }
12325 {
12326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12327 }
12328 {
12329 if (created2) delete arg2;
12330 }
12331 return resultobj;
12332 fail:
12333 {
12334 if (created2) delete arg2;
12335 }
12336 return NULL;
12337 }
12338
12339
12340 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12341 PyObject *resultobj = 0;
12342 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12343 wxString *arg2 = 0 ;
12344 void *argp1 = 0 ;
12345 int res1 = 0 ;
12346 bool temp2 = false ;
12347 PyObject * obj0 = 0 ;
12348 PyObject * obj1 = 0 ;
12349 char * kwnames[] = {
12350 (char *) "self",(char *) "name", NULL
12351 };
12352
12353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12355 if (!SWIG_IsOK(res1)) {
12356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12357 }
12358 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12359 {
12360 arg2 = wxString_in_helper(obj1);
12361 if (arg2 == NULL) SWIG_fail;
12362 temp2 = true;
12363 }
12364 {
12365 PyThreadState* __tstate = wxPyBeginAllowThreads();
12366 (arg1)->SetName((wxString const &)*arg2);
12367 wxPyEndAllowThreads(__tstate);
12368 if (PyErr_Occurred()) SWIG_fail;
12369 }
12370 resultobj = SWIG_Py_Void();
12371 {
12372 if (temp2)
12373 delete arg2;
12374 }
12375 return resultobj;
12376 fail:
12377 {
12378 if (temp2)
12379 delete arg2;
12380 }
12381 return NULL;
12382 }
12383
12384
12385 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = 0;
12387 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12388 wxString *arg2 = 0 ;
12389 void *argp1 = 0 ;
12390 int res1 = 0 ;
12391 bool temp2 = false ;
12392 PyObject * obj0 = 0 ;
12393 PyObject * obj1 = 0 ;
12394 char * kwnames[] = {
12395 (char *) "self",(char *) "extension", NULL
12396 };
12397
12398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12400 if (!SWIG_IsOK(res1)) {
12401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12402 }
12403 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12404 {
12405 arg2 = wxString_in_helper(obj1);
12406 if (arg2 == NULL) SWIG_fail;
12407 temp2 = true;
12408 }
12409 {
12410 PyThreadState* __tstate = wxPyBeginAllowThreads();
12411 (arg1)->SetExtension((wxString const &)*arg2);
12412 wxPyEndAllowThreads(__tstate);
12413 if (PyErr_Occurred()) SWIG_fail;
12414 }
12415 resultobj = SWIG_Py_Void();
12416 {
12417 if (temp2)
12418 delete arg2;
12419 }
12420 return resultobj;
12421 fail:
12422 {
12423 if (temp2)
12424 delete arg2;
12425 }
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12431 PyObject *resultobj = 0;
12432 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12433 long arg2 ;
12434 void *argp1 = 0 ;
12435 int res1 = 0 ;
12436 long val2 ;
12437 int ecode2 = 0 ;
12438 PyObject * obj0 = 0 ;
12439 PyObject * obj1 = 0 ;
12440 char * kwnames[] = {
12441 (char *) "self",(char *) "type", NULL
12442 };
12443
12444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12446 if (!SWIG_IsOK(res1)) {
12447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12448 }
12449 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12450 ecode2 = SWIG_AsVal_long(obj1, &val2);
12451 if (!SWIG_IsOK(ecode2)) {
12452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12453 }
12454 arg2 = static_cast< long >(val2);
12455 {
12456 PyThreadState* __tstate = wxPyBeginAllowThreads();
12457 (arg1)->SetType(arg2);
12458 wxPyEndAllowThreads(__tstate);
12459 if (PyErr_Occurred()) SWIG_fail;
12460 }
12461 resultobj = SWIG_Py_Void();
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj = 0;
12470 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12471 wxString *arg2 = 0 ;
12472 void *argp1 = 0 ;
12473 int res1 = 0 ;
12474 bool temp2 = false ;
12475 PyObject * obj0 = 0 ;
12476 PyObject * obj1 = 0 ;
12477 char * kwnames[] = {
12478 (char *) "self",(char *) "mimetype", NULL
12479 };
12480
12481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12485 }
12486 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12487 {
12488 arg2 = wxString_in_helper(obj1);
12489 if (arg2 == NULL) SWIG_fail;
12490 temp2 = true;
12491 }
12492 {
12493 PyThreadState* __tstate = wxPyBeginAllowThreads();
12494 (arg1)->SetMimeType((wxString const &)*arg2);
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 resultobj = SWIG_Py_Void();
12499 {
12500 if (temp2)
12501 delete arg2;
12502 }
12503 return resultobj;
12504 fail:
12505 {
12506 if (temp2)
12507 delete arg2;
12508 }
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *obj;
12515 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12516 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12517 return SWIG_Py_Void();
12518 }
12519
12520 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12521 PyObject *resultobj = 0;
12522 wxPyImageHandler *result = 0 ;
12523
12524 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12525 {
12526 PyThreadState* __tstate = wxPyBeginAllowThreads();
12527 result = (wxPyImageHandler *)new wxPyImageHandler();
12528 wxPyEndAllowThreads(__tstate);
12529 if (PyErr_Occurred()) SWIG_fail;
12530 }
12531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12532 return resultobj;
12533 fail:
12534 return NULL;
12535 }
12536
12537
12538 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12539 PyObject *resultobj = 0;
12540 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12541 PyObject *arg2 = (PyObject *) 0 ;
12542 void *argp1 = 0 ;
12543 int res1 = 0 ;
12544 PyObject * obj0 = 0 ;
12545 PyObject * obj1 = 0 ;
12546 char * kwnames[] = {
12547 (char *) "self",(char *) "self", NULL
12548 };
12549
12550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12552 if (!SWIG_IsOK(res1)) {
12553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12554 }
12555 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12556 arg2 = obj1;
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 (arg1)->_SetSelf(arg2);
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 resultobj = SWIG_Py_Void();
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12571 PyObject *obj;
12572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12573 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12574 return SWIG_Py_Void();
12575 }
12576
12577 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12578 return SWIG_Python_InitShadowInstance(args);
12579 }
12580
12581 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12582 PyObject *resultobj = 0;
12583 wxImageHistogram *result = 0 ;
12584
12585 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (wxImageHistogram *)new wxImageHistogram();
12589 wxPyEndAllowThreads(__tstate);
12590 if (PyErr_Occurred()) SWIG_fail;
12591 }
12592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12593 return resultobj;
12594 fail:
12595 return NULL;
12596 }
12597
12598
12599 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12600 PyObject *resultobj = 0;
12601 byte arg1 ;
12602 byte arg2 ;
12603 byte arg3 ;
12604 unsigned long result;
12605 unsigned char val1 ;
12606 int ecode1 = 0 ;
12607 unsigned char val2 ;
12608 int ecode2 = 0 ;
12609 unsigned char val3 ;
12610 int ecode3 = 0 ;
12611 PyObject * obj0 = 0 ;
12612 PyObject * obj1 = 0 ;
12613 PyObject * obj2 = 0 ;
12614 char * kwnames[] = {
12615 (char *) "r",(char *) "g",(char *) "b", NULL
12616 };
12617
12618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12619 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12620 if (!SWIG_IsOK(ecode1)) {
12621 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12622 }
12623 arg1 = static_cast< byte >(val1);
12624 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12625 if (!SWIG_IsOK(ecode2)) {
12626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12627 }
12628 arg2 = static_cast< byte >(val2);
12629 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12630 if (!SWIG_IsOK(ecode3)) {
12631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12632 }
12633 arg3 = static_cast< byte >(val3);
12634 {
12635 PyThreadState* __tstate = wxPyBeginAllowThreads();
12636 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12637 wxPyEndAllowThreads(__tstate);
12638 if (PyErr_Occurred()) SWIG_fail;
12639 }
12640 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj = 0;
12649 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12650 byte *arg2 = (byte *) 0 ;
12651 byte *arg3 = (byte *) 0 ;
12652 byte *arg4 = (byte *) 0 ;
12653 byte arg5 = (byte) 1 ;
12654 byte arg6 = (byte) 0 ;
12655 byte arg7 = (byte) 0 ;
12656 bool result;
12657 void *argp1 = 0 ;
12658 int res1 = 0 ;
12659 byte temp2 ;
12660 int res2 = SWIG_TMPOBJ ;
12661 byte temp3 ;
12662 int res3 = SWIG_TMPOBJ ;
12663 byte temp4 ;
12664 int res4 = SWIG_TMPOBJ ;
12665 unsigned char val5 ;
12666 int ecode5 = 0 ;
12667 unsigned char val6 ;
12668 int ecode6 = 0 ;
12669 unsigned char val7 ;
12670 int ecode7 = 0 ;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 PyObject * obj2 = 0 ;
12674 PyObject * obj3 = 0 ;
12675 char * kwnames[] = {
12676 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12677 };
12678
12679 arg2 = &temp2;
12680 arg3 = &temp3;
12681 arg4 = &temp4;
12682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12684 if (!SWIG_IsOK(res1)) {
12685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12686 }
12687 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12688 if (obj1) {
12689 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12690 if (!SWIG_IsOK(ecode5)) {
12691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12692 }
12693 arg5 = static_cast< byte >(val5);
12694 }
12695 if (obj2) {
12696 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12697 if (!SWIG_IsOK(ecode6)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12699 }
12700 arg6 = static_cast< byte >(val6);
12701 }
12702 if (obj3) {
12703 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12704 if (!SWIG_IsOK(ecode7)) {
12705 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12706 }
12707 arg7 = static_cast< byte >(val7);
12708 }
12709 {
12710 PyThreadState* __tstate = wxPyBeginAllowThreads();
12711 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12712 wxPyEndAllowThreads(__tstate);
12713 if (PyErr_Occurred()) SWIG_fail;
12714 }
12715 {
12716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12717 }
12718 if (SWIG_IsTmpObj(res2)) {
12719 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12720 } else {
12721 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12723 }
12724 if (SWIG_IsTmpObj(res3)) {
12725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12726 } else {
12727 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12729 }
12730 if (SWIG_IsTmpObj(res4)) {
12731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12732 } else {
12733 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12735 }
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12745 unsigned long arg2 ;
12746 unsigned long result;
12747 void *argp1 = 0 ;
12748 int res1 = 0 ;
12749 unsigned long val2 ;
12750 int ecode2 = 0 ;
12751 PyObject * obj0 = 0 ;
12752 PyObject * obj1 = 0 ;
12753 char * kwnames[] = {
12754 (char *) "self",(char *) "key", NULL
12755 };
12756
12757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12759 if (!SWIG_IsOK(res1)) {
12760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12761 }
12762 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12763 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12764 if (!SWIG_IsOK(ecode2)) {
12765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12766 }
12767 arg2 = static_cast< unsigned long >(val2);
12768 {
12769 PyThreadState* __tstate = wxPyBeginAllowThreads();
12770 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12771 wxPyEndAllowThreads(__tstate);
12772 if (PyErr_Occurred()) SWIG_fail;
12773 }
12774 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12775 return resultobj;
12776 fail:
12777 return NULL;
12778 }
12779
12780
12781 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12782 PyObject *resultobj = 0;
12783 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12784 byte arg2 ;
12785 byte arg3 ;
12786 byte arg4 ;
12787 unsigned long result;
12788 void *argp1 = 0 ;
12789 int res1 = 0 ;
12790 unsigned char val2 ;
12791 int ecode2 = 0 ;
12792 unsigned char val3 ;
12793 int ecode3 = 0 ;
12794 unsigned char val4 ;
12795 int ecode4 = 0 ;
12796 PyObject * obj0 = 0 ;
12797 PyObject * obj1 = 0 ;
12798 PyObject * obj2 = 0 ;
12799 PyObject * obj3 = 0 ;
12800 char * kwnames[] = {
12801 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12802 };
12803
12804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12808 }
12809 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12810 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12811 if (!SWIG_IsOK(ecode2)) {
12812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12813 }
12814 arg2 = static_cast< byte >(val2);
12815 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12816 if (!SWIG_IsOK(ecode3)) {
12817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12818 }
12819 arg3 = static_cast< byte >(val3);
12820 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12821 if (!SWIG_IsOK(ecode4)) {
12822 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12823 }
12824 arg4 = static_cast< byte >(val4);
12825 {
12826 PyThreadState* __tstate = wxPyBeginAllowThreads();
12827 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12828 wxPyEndAllowThreads(__tstate);
12829 if (PyErr_Occurred()) SWIG_fail;
12830 }
12831 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12832 return resultobj;
12833 fail:
12834 return NULL;
12835 }
12836
12837
12838 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12839 PyObject *resultobj = 0;
12840 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12841 wxColour *arg2 = 0 ;
12842 unsigned long result;
12843 void *argp1 = 0 ;
12844 int res1 = 0 ;
12845 wxColour temp2 ;
12846 PyObject * obj0 = 0 ;
12847 PyObject * obj1 = 0 ;
12848 char * kwnames[] = {
12849 (char *) "self",(char *) "colour", NULL
12850 };
12851
12852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12854 if (!SWIG_IsOK(res1)) {
12855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12856 }
12857 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12858 {
12859 arg2 = &temp2;
12860 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12861 }
12862 {
12863 PyThreadState* __tstate = wxPyBeginAllowThreads();
12864 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12865 wxPyEndAllowThreads(__tstate);
12866 if (PyErr_Occurred()) SWIG_fail;
12867 }
12868 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12869 return resultobj;
12870 fail:
12871 return NULL;
12872 }
12873
12874
12875 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12876 PyObject *obj;
12877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12878 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12879 return SWIG_Py_Void();
12880 }
12881
12882 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12883 return SWIG_Python_InitShadowInstance(args);
12884 }
12885
12886 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12887 PyObject *resultobj = 0;
12888 byte arg1 = (byte) 0 ;
12889 byte arg2 = (byte) 0 ;
12890 byte arg3 = (byte) 0 ;
12891 wxImage_RGBValue *result = 0 ;
12892 unsigned char val1 ;
12893 int ecode1 = 0 ;
12894 unsigned char val2 ;
12895 int ecode2 = 0 ;
12896 unsigned char val3 ;
12897 int ecode3 = 0 ;
12898 PyObject * obj0 = 0 ;
12899 PyObject * obj1 = 0 ;
12900 PyObject * obj2 = 0 ;
12901 char * kwnames[] = {
12902 (char *) "r",(char *) "g",(char *) "b", NULL
12903 };
12904
12905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12906 if (obj0) {
12907 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12908 if (!SWIG_IsOK(ecode1)) {
12909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12910 }
12911 arg1 = static_cast< byte >(val1);
12912 }
12913 if (obj1) {
12914 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12915 if (!SWIG_IsOK(ecode2)) {
12916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12917 }
12918 arg2 = static_cast< byte >(val2);
12919 }
12920 if (obj2) {
12921 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12922 if (!SWIG_IsOK(ecode3)) {
12923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12924 }
12925 arg3 = static_cast< byte >(val3);
12926 }
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12930 wxPyEndAllowThreads(__tstate);
12931 if (PyErr_Occurred()) SWIG_fail;
12932 }
12933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12934 return resultobj;
12935 fail:
12936 return NULL;
12937 }
12938
12939
12940 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12941 PyObject *resultobj = 0;
12942 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12943 byte arg2 ;
12944 void *argp1 = 0 ;
12945 int res1 = 0 ;
12946 unsigned char val2 ;
12947 int ecode2 = 0 ;
12948 PyObject *swig_obj[2] ;
12949
12950 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12952 if (!SWIG_IsOK(res1)) {
12953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12954 }
12955 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12956 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12957 if (!SWIG_IsOK(ecode2)) {
12958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12959 }
12960 arg2 = static_cast< byte >(val2);
12961 if (arg1) (arg1)->red = arg2;
12962
12963 resultobj = SWIG_Py_Void();
12964 return resultobj;
12965 fail:
12966 return NULL;
12967 }
12968
12969
12970 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12971 PyObject *resultobj = 0;
12972 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12973 byte result;
12974 void *argp1 = 0 ;
12975 int res1 = 0 ;
12976 PyObject *swig_obj[1] ;
12977
12978 if (!args) SWIG_fail;
12979 swig_obj[0] = args;
12980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12981 if (!SWIG_IsOK(res1)) {
12982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12983 }
12984 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12985 result = (byte) ((arg1)->red);
12986 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12994 PyObject *resultobj = 0;
12995 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12996 byte arg2 ;
12997 void *argp1 = 0 ;
12998 int res1 = 0 ;
12999 unsigned char val2 ;
13000 int ecode2 = 0 ;
13001 PyObject *swig_obj[2] ;
13002
13003 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
13004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13005 if (!SWIG_IsOK(res1)) {
13006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13007 }
13008 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13009 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13010 if (!SWIG_IsOK(ecode2)) {
13011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
13012 }
13013 arg2 = static_cast< byte >(val2);
13014 if (arg1) (arg1)->green = arg2;
13015
13016 resultobj = SWIG_Py_Void();
13017 return resultobj;
13018 fail:
13019 return NULL;
13020 }
13021
13022
13023 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13024 PyObject *resultobj = 0;
13025 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13026 byte result;
13027 void *argp1 = 0 ;
13028 int res1 = 0 ;
13029 PyObject *swig_obj[1] ;
13030
13031 if (!args) SWIG_fail;
13032 swig_obj[0] = args;
13033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13034 if (!SWIG_IsOK(res1)) {
13035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13036 }
13037 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13038 result = (byte) ((arg1)->green);
13039 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13040 return resultobj;
13041 fail:
13042 return NULL;
13043 }
13044
13045
13046 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13047 PyObject *resultobj = 0;
13048 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13049 byte arg2 ;
13050 void *argp1 = 0 ;
13051 int res1 = 0 ;
13052 unsigned char val2 ;
13053 int ecode2 = 0 ;
13054 PyObject *swig_obj[2] ;
13055
13056 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
13057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13058 if (!SWIG_IsOK(res1)) {
13059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13060 }
13061 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13062 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
13063 if (!SWIG_IsOK(ecode2)) {
13064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
13065 }
13066 arg2 = static_cast< byte >(val2);
13067 if (arg1) (arg1)->blue = arg2;
13068
13069 resultobj = SWIG_Py_Void();
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13077 PyObject *resultobj = 0;
13078 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
13079 byte result;
13080 void *argp1 = 0 ;
13081 int res1 = 0 ;
13082 PyObject *swig_obj[1] ;
13083
13084 if (!args) SWIG_fail;
13085 swig_obj[0] = args;
13086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
13087 if (!SWIG_IsOK(res1)) {
13088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
13089 }
13090 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
13091 result = (byte) ((arg1)->blue);
13092 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13100 PyObject *obj;
13101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13102 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
13103 return SWIG_Py_Void();
13104 }
13105
13106 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13107 return SWIG_Python_InitShadowInstance(args);
13108 }
13109
13110 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13111 PyObject *resultobj = 0;
13112 double arg1 = (double) 0.0 ;
13113 double arg2 = (double) 0.0 ;
13114 double arg3 = (double) 0.0 ;
13115 wxImage_HSVValue *result = 0 ;
13116 double val1 ;
13117 int ecode1 = 0 ;
13118 double val2 ;
13119 int ecode2 = 0 ;
13120 double val3 ;
13121 int ecode3 = 0 ;
13122 PyObject * obj0 = 0 ;
13123 PyObject * obj1 = 0 ;
13124 PyObject * obj2 = 0 ;
13125 char * kwnames[] = {
13126 (char *) "h",(char *) "s",(char *) "v", NULL
13127 };
13128
13129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13130 if (obj0) {
13131 ecode1 = SWIG_AsVal_double(obj0, &val1);
13132 if (!SWIG_IsOK(ecode1)) {
13133 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13134 }
13135 arg1 = static_cast< double >(val1);
13136 }
13137 if (obj1) {
13138 ecode2 = SWIG_AsVal_double(obj1, &val2);
13139 if (!SWIG_IsOK(ecode2)) {
13140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13141 }
13142 arg2 = static_cast< double >(val2);
13143 }
13144 if (obj2) {
13145 ecode3 = SWIG_AsVal_double(obj2, &val3);
13146 if (!SWIG_IsOK(ecode3)) {
13147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13148 }
13149 arg3 = static_cast< double >(val3);
13150 }
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13154 wxPyEndAllowThreads(__tstate);
13155 if (PyErr_Occurred()) SWIG_fail;
13156 }
13157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13158 return resultobj;
13159 fail:
13160 return NULL;
13161 }
13162
13163
13164 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13165 PyObject *resultobj = 0;
13166 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13167 double arg2 ;
13168 void *argp1 = 0 ;
13169 int res1 = 0 ;
13170 double val2 ;
13171 int ecode2 = 0 ;
13172 PyObject *swig_obj[2] ;
13173
13174 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13176 if (!SWIG_IsOK(res1)) {
13177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13178 }
13179 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13180 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13181 if (!SWIG_IsOK(ecode2)) {
13182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13183 }
13184 arg2 = static_cast< double >(val2);
13185 if (arg1) (arg1)->hue = arg2;
13186
13187 resultobj = SWIG_Py_Void();
13188 return resultobj;
13189 fail:
13190 return NULL;
13191 }
13192
13193
13194 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13195 PyObject *resultobj = 0;
13196 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13197 double result;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 PyObject *swig_obj[1] ;
13201
13202 if (!args) SWIG_fail;
13203 swig_obj[0] = args;
13204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13205 if (!SWIG_IsOK(res1)) {
13206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13207 }
13208 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13209 result = (double) ((arg1)->hue);
13210 resultobj = SWIG_From_double(static_cast< double >(result));
13211 return resultobj;
13212 fail:
13213 return NULL;
13214 }
13215
13216
13217 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13218 PyObject *resultobj = 0;
13219 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13220 double arg2 ;
13221 void *argp1 = 0 ;
13222 int res1 = 0 ;
13223 double val2 ;
13224 int ecode2 = 0 ;
13225 PyObject *swig_obj[2] ;
13226
13227 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13229 if (!SWIG_IsOK(res1)) {
13230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13231 }
13232 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13233 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13234 if (!SWIG_IsOK(ecode2)) {
13235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13236 }
13237 arg2 = static_cast< double >(val2);
13238 if (arg1) (arg1)->saturation = arg2;
13239
13240 resultobj = SWIG_Py_Void();
13241 return resultobj;
13242 fail:
13243 return NULL;
13244 }
13245
13246
13247 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13248 PyObject *resultobj = 0;
13249 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13250 double result;
13251 void *argp1 = 0 ;
13252 int res1 = 0 ;
13253 PyObject *swig_obj[1] ;
13254
13255 if (!args) SWIG_fail;
13256 swig_obj[0] = args;
13257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13258 if (!SWIG_IsOK(res1)) {
13259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13260 }
13261 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13262 result = (double) ((arg1)->saturation);
13263 resultobj = SWIG_From_double(static_cast< double >(result));
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13271 PyObject *resultobj = 0;
13272 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13273 double arg2 ;
13274 void *argp1 = 0 ;
13275 int res1 = 0 ;
13276 double val2 ;
13277 int ecode2 = 0 ;
13278 PyObject *swig_obj[2] ;
13279
13280 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13282 if (!SWIG_IsOK(res1)) {
13283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13284 }
13285 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13286 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13287 if (!SWIG_IsOK(ecode2)) {
13288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13289 }
13290 arg2 = static_cast< double >(val2);
13291 if (arg1) (arg1)->value = arg2;
13292
13293 resultobj = SWIG_Py_Void();
13294 return resultobj;
13295 fail:
13296 return NULL;
13297 }
13298
13299
13300 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13301 PyObject *resultobj = 0;
13302 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13303 double result;
13304 void *argp1 = 0 ;
13305 int res1 = 0 ;
13306 PyObject *swig_obj[1] ;
13307
13308 if (!args) SWIG_fail;
13309 swig_obj[0] = args;
13310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13311 if (!SWIG_IsOK(res1)) {
13312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13313 }
13314 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13315 result = (double) ((arg1)->value);
13316 resultobj = SWIG_From_double(static_cast< double >(result));
13317 return resultobj;
13318 fail:
13319 return NULL;
13320 }
13321
13322
13323 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13324 PyObject *obj;
13325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13326 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13327 return SWIG_Py_Void();
13328 }
13329
13330 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13331 return SWIG_Python_InitShadowInstance(args);
13332 }
13333
13334 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13335 PyObject *resultobj = 0;
13336 wxString *arg1 = 0 ;
13337 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13338 int arg3 = (int) -1 ;
13339 wxImage *result = 0 ;
13340 bool temp1 = false ;
13341 long val2 ;
13342 int ecode2 = 0 ;
13343 int val3 ;
13344 int ecode3 = 0 ;
13345 PyObject * obj0 = 0 ;
13346 PyObject * obj1 = 0 ;
13347 PyObject * obj2 = 0 ;
13348 char * kwnames[] = {
13349 (char *) "name",(char *) "type",(char *) "index", NULL
13350 };
13351
13352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13353 {
13354 arg1 = wxString_in_helper(obj0);
13355 if (arg1 == NULL) SWIG_fail;
13356 temp1 = true;
13357 }
13358 if (obj1) {
13359 ecode2 = SWIG_AsVal_long(obj1, &val2);
13360 if (!SWIG_IsOK(ecode2)) {
13361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13362 }
13363 arg2 = static_cast< long >(val2);
13364 }
13365 if (obj2) {
13366 ecode3 = SWIG_AsVal_int(obj2, &val3);
13367 if (!SWIG_IsOK(ecode3)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13369 }
13370 arg3 = static_cast< int >(val3);
13371 }
13372 {
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13375 wxPyEndAllowThreads(__tstate);
13376 if (PyErr_Occurred()) SWIG_fail;
13377 }
13378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13379 {
13380 if (temp1)
13381 delete arg1;
13382 }
13383 return resultobj;
13384 fail:
13385 {
13386 if (temp1)
13387 delete arg1;
13388 }
13389 return NULL;
13390 }
13391
13392
13393 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13394 PyObject *resultobj = 0;
13395 wxImage *arg1 = (wxImage *) 0 ;
13396 void *argp1 = 0 ;
13397 int res1 = 0 ;
13398 PyObject *swig_obj[1] ;
13399
13400 if (!args) SWIG_fail;
13401 swig_obj[0] = args;
13402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13405 }
13406 arg1 = reinterpret_cast< wxImage * >(argp1);
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 delete arg1;
13410
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 resultobj = SWIG_Py_Void();
13415 return resultobj;
13416 fail:
13417 return NULL;
13418 }
13419
13420
13421 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13422 PyObject *resultobj = 0;
13423 wxString *arg1 = 0 ;
13424 wxString *arg2 = 0 ;
13425 int arg3 = (int) -1 ;
13426 wxImage *result = 0 ;
13427 bool temp1 = false ;
13428 bool temp2 = false ;
13429 int val3 ;
13430 int ecode3 = 0 ;
13431 PyObject * obj0 = 0 ;
13432 PyObject * obj1 = 0 ;
13433 PyObject * obj2 = 0 ;
13434 char * kwnames[] = {
13435 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13436 };
13437
13438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13439 {
13440 arg1 = wxString_in_helper(obj0);
13441 if (arg1 == NULL) SWIG_fail;
13442 temp1 = true;
13443 }
13444 {
13445 arg2 = wxString_in_helper(obj1);
13446 if (arg2 == NULL) SWIG_fail;
13447 temp2 = true;
13448 }
13449 if (obj2) {
13450 ecode3 = SWIG_AsVal_int(obj2, &val3);
13451 if (!SWIG_IsOK(ecode3)) {
13452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13453 }
13454 arg3 = static_cast< int >(val3);
13455 }
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13459 wxPyEndAllowThreads(__tstate);
13460 if (PyErr_Occurred()) SWIG_fail;
13461 }
13462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13463 {
13464 if (temp1)
13465 delete arg1;
13466 }
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return resultobj;
13472 fail:
13473 {
13474 if (temp1)
13475 delete arg1;
13476 }
13477 {
13478 if (temp2)
13479 delete arg2;
13480 }
13481 return NULL;
13482 }
13483
13484
13485 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13486 PyObject *resultobj = 0;
13487 wxInputStream *arg1 = 0 ;
13488 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13489 int arg3 = (int) -1 ;
13490 wxImage *result = 0 ;
13491 wxPyInputStream *temp1 ;
13492 bool created1 ;
13493 long val2 ;
13494 int ecode2 = 0 ;
13495 int val3 ;
13496 int ecode3 = 0 ;
13497 PyObject * obj0 = 0 ;
13498 PyObject * obj1 = 0 ;
13499 PyObject * obj2 = 0 ;
13500 char * kwnames[] = {
13501 (char *) "stream",(char *) "type",(char *) "index", NULL
13502 };
13503
13504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13505 {
13506 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13507 arg1 = temp1->m_wxis;
13508 created1 = false;
13509 } else {
13510 PyErr_Clear(); // clear the failure of the wxPyConvert above
13511 arg1 = wxPyCBInputStream_create(obj0, false);
13512 if (arg1 == NULL) {
13513 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13514 SWIG_fail;
13515 }
13516 created1 = true;
13517 }
13518 }
13519 if (obj1) {
13520 ecode2 = SWIG_AsVal_long(obj1, &val2);
13521 if (!SWIG_IsOK(ecode2)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13523 }
13524 arg2 = static_cast< long >(val2);
13525 }
13526 if (obj2) {
13527 ecode3 = SWIG_AsVal_int(obj2, &val3);
13528 if (!SWIG_IsOK(ecode3)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13530 }
13531 arg3 = static_cast< int >(val3);
13532 }
13533 {
13534 PyThreadState* __tstate = wxPyBeginAllowThreads();
13535 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13536 wxPyEndAllowThreads(__tstate);
13537 if (PyErr_Occurred()) SWIG_fail;
13538 }
13539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13540 {
13541 if (created1) delete arg1;
13542 }
13543 return resultobj;
13544 fail:
13545 {
13546 if (created1) delete arg1;
13547 }
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxInputStream *arg1 = 0 ;
13555 wxString *arg2 = 0 ;
13556 int arg3 = (int) -1 ;
13557 wxImage *result = 0 ;
13558 wxPyInputStream *temp1 ;
13559 bool created1 ;
13560 bool temp2 = false ;
13561 int val3 ;
13562 int ecode3 = 0 ;
13563 PyObject * obj0 = 0 ;
13564 PyObject * obj1 = 0 ;
13565 PyObject * obj2 = 0 ;
13566 char * kwnames[] = {
13567 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13568 };
13569
13570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13571 {
13572 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13573 arg1 = temp1->m_wxis;
13574 created1 = false;
13575 } else {
13576 PyErr_Clear(); // clear the failure of the wxPyConvert above
13577 arg1 = wxPyCBInputStream_create(obj0, false);
13578 if (arg1 == NULL) {
13579 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13580 SWIG_fail;
13581 }
13582 created1 = true;
13583 }
13584 }
13585 {
13586 arg2 = wxString_in_helper(obj1);
13587 if (arg2 == NULL) SWIG_fail;
13588 temp2 = true;
13589 }
13590 if (obj2) {
13591 ecode3 = SWIG_AsVal_int(obj2, &val3);
13592 if (!SWIG_IsOK(ecode3)) {
13593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13594 }
13595 arg3 = static_cast< int >(val3);
13596 }
13597 {
13598 PyThreadState* __tstate = wxPyBeginAllowThreads();
13599 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13604 {
13605 if (created1) delete arg1;
13606 }
13607 {
13608 if (temp2)
13609 delete arg2;
13610 }
13611 return resultobj;
13612 fail:
13613 {
13614 if (created1) delete arg1;
13615 }
13616 {
13617 if (temp2)
13618 delete arg2;
13619 }
13620 return NULL;
13621 }
13622
13623
13624 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13625 PyObject *resultobj = 0;
13626 int arg1 = (int) 0 ;
13627 int arg2 = (int) 0 ;
13628 bool arg3 = (bool) true ;
13629 wxImage *result = 0 ;
13630 int val1 ;
13631 int ecode1 = 0 ;
13632 int val2 ;
13633 int ecode2 = 0 ;
13634 bool val3 ;
13635 int ecode3 = 0 ;
13636 PyObject * obj0 = 0 ;
13637 PyObject * obj1 = 0 ;
13638 PyObject * obj2 = 0 ;
13639 char * kwnames[] = {
13640 (char *) "width",(char *) "height",(char *) "clear", NULL
13641 };
13642
13643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13644 if (obj0) {
13645 ecode1 = SWIG_AsVal_int(obj0, &val1);
13646 if (!SWIG_IsOK(ecode1)) {
13647 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13648 }
13649 arg1 = static_cast< int >(val1);
13650 }
13651 if (obj1) {
13652 ecode2 = SWIG_AsVal_int(obj1, &val2);
13653 if (!SWIG_IsOK(ecode2)) {
13654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13655 }
13656 arg2 = static_cast< int >(val2);
13657 }
13658 if (obj2) {
13659 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13660 if (!SWIG_IsOK(ecode3)) {
13661 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13662 }
13663 arg3 = static_cast< bool >(val3);
13664 }
13665 {
13666 PyThreadState* __tstate = wxPyBeginAllowThreads();
13667 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13668 wxPyEndAllowThreads(__tstate);
13669 if (PyErr_Occurred()) SWIG_fail;
13670 }
13671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13672 return resultobj;
13673 fail:
13674 return NULL;
13675 }
13676
13677
13678 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13679 PyObject *resultobj = 0;
13680 wxBitmap *arg1 = 0 ;
13681 wxImage *result = 0 ;
13682 void *argp1 = 0 ;
13683 int res1 = 0 ;
13684 PyObject * obj0 = 0 ;
13685 char * kwnames[] = {
13686 (char *) "bitmap", NULL
13687 };
13688
13689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13690 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13691 if (!SWIG_IsOK(res1)) {
13692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13693 }
13694 if (!argp1) {
13695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13696 }
13697 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13698 {
13699 if (!wxPyCheckForApp()) SWIG_fail;
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj = 0;
13714 int arg1 ;
13715 int arg2 ;
13716 buffer arg3 ;
13717 int arg4 ;
13718 wxImage *result = 0 ;
13719 int val1 ;
13720 int ecode1 = 0 ;
13721 int val2 ;
13722 int ecode2 = 0 ;
13723 Py_ssize_t temp3 ;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 PyObject * obj2 = 0 ;
13727 char * kwnames[] = {
13728 (char *) "width",(char *) "height",(char *) "data", NULL
13729 };
13730
13731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13732 ecode1 = SWIG_AsVal_int(obj0, &val1);
13733 if (!SWIG_IsOK(ecode1)) {
13734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13735 }
13736 arg1 = static_cast< int >(val1);
13737 ecode2 = SWIG_AsVal_int(obj1, &val2);
13738 if (!SWIG_IsOK(ecode2)) {
13739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13740 }
13741 arg2 = static_cast< int >(val2);
13742 {
13743 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13744 arg4 = (int)temp3;
13745 }
13746 {
13747 PyThreadState* __tstate = wxPyBeginAllowThreads();
13748 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13749 wxPyEndAllowThreads(__tstate);
13750 if (PyErr_Occurred()) SWIG_fail;
13751 }
13752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13753 return resultobj;
13754 fail:
13755 return NULL;
13756 }
13757
13758
13759 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13760 PyObject *resultobj = 0;
13761 int arg1 ;
13762 int arg2 ;
13763 buffer arg3 ;
13764 int arg4 ;
13765 buffer arg5 ;
13766 int arg6 ;
13767 wxImage *result = 0 ;
13768 int val1 ;
13769 int ecode1 = 0 ;
13770 int val2 ;
13771 int ecode2 = 0 ;
13772 Py_ssize_t temp3 ;
13773 Py_ssize_t temp5 ;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13783 ecode1 = SWIG_AsVal_int(obj0, &val1);
13784 if (!SWIG_IsOK(ecode1)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13786 }
13787 arg1 = static_cast< int >(val1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 {
13794 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13795 arg4 = (int)temp3;
13796 }
13797 {
13798 if (obj3 != Py_None) {
13799 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13800 arg6 = (int)temp5;
13801 }
13802 }
13803 {
13804 PyThreadState* __tstate = wxPyBeginAllowThreads();
13805 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13810 return resultobj;
13811 fail:
13812 return NULL;
13813 }
13814
13815
13816 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13817 PyObject *resultobj = 0;
13818 wxImage *arg1 = (wxImage *) 0 ;
13819 int arg2 ;
13820 int arg3 ;
13821 bool arg4 = (bool) true ;
13822 void *argp1 = 0 ;
13823 int res1 = 0 ;
13824 int val2 ;
13825 int ecode2 = 0 ;
13826 int val3 ;
13827 int ecode3 = 0 ;
13828 bool val4 ;
13829 int ecode4 = 0 ;
13830 PyObject * obj0 = 0 ;
13831 PyObject * obj1 = 0 ;
13832 PyObject * obj2 = 0 ;
13833 PyObject * obj3 = 0 ;
13834 char * kwnames[] = {
13835 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13836 };
13837
13838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13840 if (!SWIG_IsOK(res1)) {
13841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13842 }
13843 arg1 = reinterpret_cast< wxImage * >(argp1);
13844 ecode2 = SWIG_AsVal_int(obj1, &val2);
13845 if (!SWIG_IsOK(ecode2)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13847 }
13848 arg2 = static_cast< int >(val2);
13849 ecode3 = SWIG_AsVal_int(obj2, &val3);
13850 if (!SWIG_IsOK(ecode3)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13852 }
13853 arg3 = static_cast< int >(val3);
13854 if (obj3) {
13855 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13856 if (!SWIG_IsOK(ecode4)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13858 }
13859 arg4 = static_cast< bool >(val4);
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 (arg1)->Create(arg2,arg3,arg4);
13864 wxPyEndAllowThreads(__tstate);
13865 if (PyErr_Occurred()) SWIG_fail;
13866 }
13867 resultobj = SWIG_Py_Void();
13868 return resultobj;
13869 fail:
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13875 PyObject *resultobj = 0;
13876 wxImage *arg1 = (wxImage *) 0 ;
13877 void *argp1 = 0 ;
13878 int res1 = 0 ;
13879 PyObject *swig_obj[1] ;
13880
13881 if (!args) SWIG_fail;
13882 swig_obj[0] = args;
13883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13884 if (!SWIG_IsOK(res1)) {
13885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13886 }
13887 arg1 = reinterpret_cast< wxImage * >(argp1);
13888 {
13889 PyThreadState* __tstate = wxPyBeginAllowThreads();
13890 (arg1)->Destroy();
13891 wxPyEndAllowThreads(__tstate);
13892 if (PyErr_Occurred()) SWIG_fail;
13893 }
13894 resultobj = SWIG_Py_Void();
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxImage *arg1 = (wxImage *) 0 ;
13904 int arg2 ;
13905 int arg3 ;
13906 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
13907 SwigValueWrapper<wxImage > result;
13908 void *argp1 = 0 ;
13909 int res1 = 0 ;
13910 int val2 ;
13911 int ecode2 = 0 ;
13912 int val3 ;
13913 int ecode3 = 0 ;
13914 int val4 ;
13915 int ecode4 = 0 ;
13916 PyObject * obj0 = 0 ;
13917 PyObject * obj1 = 0 ;
13918 PyObject * obj2 = 0 ;
13919 PyObject * obj3 = 0 ;
13920 char * kwnames[] = {
13921 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
13922 };
13923
13924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13926 if (!SWIG_IsOK(res1)) {
13927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13928 }
13929 arg1 = reinterpret_cast< wxImage * >(argp1);
13930 ecode2 = SWIG_AsVal_int(obj1, &val2);
13931 if (!SWIG_IsOK(ecode2)) {
13932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13933 }
13934 arg2 = static_cast< int >(val2);
13935 ecode3 = SWIG_AsVal_int(obj2, &val3);
13936 if (!SWIG_IsOK(ecode3)) {
13937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13938 }
13939 arg3 = static_cast< int >(val3);
13940 if (obj3) {
13941 ecode4 = SWIG_AsVal_int(obj3, &val4);
13942 if (!SWIG_IsOK(ecode4)) {
13943 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
13944 }
13945 arg4 = static_cast< int >(val4);
13946 }
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 result = (arg1)->Scale(arg2,arg3,arg4);
13950 wxPyEndAllowThreads(__tstate);
13951 if (PyErr_Occurred()) SWIG_fail;
13952 }
13953 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13954 return resultobj;
13955 fail:
13956 return NULL;
13957 }
13958
13959
13960 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13961 PyObject *resultobj = 0;
13962 wxImage *arg1 = (wxImage *) 0 ;
13963 int arg2 ;
13964 int arg3 ;
13965 SwigValueWrapper<wxImage > result;
13966 void *argp1 = 0 ;
13967 int res1 = 0 ;
13968 int val2 ;
13969 int ecode2 = 0 ;
13970 int val3 ;
13971 int ecode3 = 0 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 char * kwnames[] = {
13976 (char *) "self",(char *) "width",(char *) "height", NULL
13977 };
13978
13979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13981 if (!SWIG_IsOK(res1)) {
13982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
13983 }
13984 arg1 = reinterpret_cast< wxImage * >(argp1);
13985 ecode2 = SWIG_AsVal_int(obj1, &val2);
13986 if (!SWIG_IsOK(ecode2)) {
13987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
13988 }
13989 arg2 = static_cast< int >(val2);
13990 ecode3 = SWIG_AsVal_int(obj2, &val3);
13991 if (!SWIG_IsOK(ecode3)) {
13992 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
13993 }
13994 arg3 = static_cast< int >(val3);
13995 {
13996 PyThreadState* __tstate = wxPyBeginAllowThreads();
13997 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
13998 wxPyEndAllowThreads(__tstate);
13999 if (PyErr_Occurred()) SWIG_fail;
14000 }
14001 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14002 return resultobj;
14003 fail:
14004 return NULL;
14005 }
14006
14007
14008 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14009 PyObject *resultobj = 0;
14010 wxImage *arg1 = (wxImage *) 0 ;
14011 int arg2 ;
14012 int arg3 ;
14013 SwigValueWrapper<wxImage > result;
14014 void *argp1 = 0 ;
14015 int res1 = 0 ;
14016 int val2 ;
14017 int ecode2 = 0 ;
14018 int val3 ;
14019 int ecode3 = 0 ;
14020 PyObject * obj0 = 0 ;
14021 PyObject * obj1 = 0 ;
14022 PyObject * obj2 = 0 ;
14023 char * kwnames[] = {
14024 (char *) "self",(char *) "width",(char *) "height", NULL
14025 };
14026
14027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14029 if (!SWIG_IsOK(res1)) {
14030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
14031 }
14032 arg1 = reinterpret_cast< wxImage * >(argp1);
14033 ecode2 = SWIG_AsVal_int(obj1, &val2);
14034 if (!SWIG_IsOK(ecode2)) {
14035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
14036 }
14037 arg2 = static_cast< int >(val2);
14038 ecode3 = SWIG_AsVal_int(obj2, &val3);
14039 if (!SWIG_IsOK(ecode3)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
14041 }
14042 arg3 = static_cast< int >(val3);
14043 {
14044 PyThreadState* __tstate = wxPyBeginAllowThreads();
14045 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
14046 wxPyEndAllowThreads(__tstate);
14047 if (PyErr_Occurred()) SWIG_fail;
14048 }
14049 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14050 return resultobj;
14051 fail:
14052 return NULL;
14053 }
14054
14055
14056 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14057 PyObject *resultobj = 0;
14058 wxImage *arg1 = (wxImage *) 0 ;
14059 int arg2 ;
14060 SwigValueWrapper<wxImage > result;
14061 void *argp1 = 0 ;
14062 int res1 = 0 ;
14063 int val2 ;
14064 int ecode2 = 0 ;
14065 PyObject * obj0 = 0 ;
14066 PyObject * obj1 = 0 ;
14067 char * kwnames[] = {
14068 (char *) "self",(char *) "radius", NULL
14069 };
14070
14071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
14072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14073 if (!SWIG_IsOK(res1)) {
14074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
14075 }
14076 arg1 = reinterpret_cast< wxImage * >(argp1);
14077 ecode2 = SWIG_AsVal_int(obj1, &val2);
14078 if (!SWIG_IsOK(ecode2)) {
14079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
14080 }
14081 arg2 = static_cast< int >(val2);
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = (arg1)->Blur(arg2);
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj = 0;
14097 wxImage *arg1 = (wxImage *) 0 ;
14098 int arg2 ;
14099 SwigValueWrapper<wxImage > result;
14100 void *argp1 = 0 ;
14101 int res1 = 0 ;
14102 int val2 ;
14103 int ecode2 = 0 ;
14104 PyObject * obj0 = 0 ;
14105 PyObject * obj1 = 0 ;
14106 char * kwnames[] = {
14107 (char *) "self",(char *) "radius", NULL
14108 };
14109
14110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
14111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14112 if (!SWIG_IsOK(res1)) {
14113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
14114 }
14115 arg1 = reinterpret_cast< wxImage * >(argp1);
14116 ecode2 = SWIG_AsVal_int(obj1, &val2);
14117 if (!SWIG_IsOK(ecode2)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
14119 }
14120 arg2 = static_cast< int >(val2);
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (arg1)->BlurHorizontal(arg2);
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14128 return resultobj;
14129 fail:
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxImage *arg1 = (wxImage *) 0 ;
14137 int arg2 ;
14138 SwigValueWrapper<wxImage > result;
14139 void *argp1 = 0 ;
14140 int res1 = 0 ;
14141 int val2 ;
14142 int ecode2 = 0 ;
14143 PyObject * obj0 = 0 ;
14144 PyObject * obj1 = 0 ;
14145 char * kwnames[] = {
14146 (char *) "self",(char *) "radius", NULL
14147 };
14148
14149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
14150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14151 if (!SWIG_IsOK(res1)) {
14152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
14153 }
14154 arg1 = reinterpret_cast< wxImage * >(argp1);
14155 ecode2 = SWIG_AsVal_int(obj1, &val2);
14156 if (!SWIG_IsOK(ecode2)) {
14157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
14158 }
14159 arg2 = static_cast< int >(val2);
14160 {
14161 PyThreadState* __tstate = wxPyBeginAllowThreads();
14162 result = (arg1)->BlurVertical(arg2);
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14167 return resultobj;
14168 fail:
14169 return NULL;
14170 }
14171
14172
14173 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14174 PyObject *resultobj = 0;
14175 wxImage *arg1 = (wxImage *) 0 ;
14176 int arg2 ;
14177 int arg3 ;
14178 SwigValueWrapper<wxImage > result;
14179 void *argp1 = 0 ;
14180 int res1 = 0 ;
14181 int val2 ;
14182 int ecode2 = 0 ;
14183 int val3 ;
14184 int ecode3 = 0 ;
14185 PyObject * obj0 = 0 ;
14186 PyObject * obj1 = 0 ;
14187 PyObject * obj2 = 0 ;
14188 char * kwnames[] = {
14189 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
14190 };
14191
14192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14194 if (!SWIG_IsOK(res1)) {
14195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
14196 }
14197 arg1 = reinterpret_cast< wxImage * >(argp1);
14198 ecode2 = SWIG_AsVal_int(obj1, &val2);
14199 if (!SWIG_IsOK(ecode2)) {
14200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
14201 }
14202 arg2 = static_cast< int >(val2);
14203 ecode3 = SWIG_AsVal_int(obj2, &val3);
14204 if (!SWIG_IsOK(ecode3)) {
14205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
14206 }
14207 arg3 = static_cast< int >(val3);
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
14211 wxPyEndAllowThreads(__tstate);
14212 if (PyErr_Occurred()) SWIG_fail;
14213 }
14214 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj = 0;
14223 wxImage *arg1 = (wxImage *) 0 ;
14224 int arg2 ;
14225 int arg3 ;
14226 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
14227 wxImage *result = 0 ;
14228 void *argp1 = 0 ;
14229 int res1 = 0 ;
14230 int val2 ;
14231 int ecode2 = 0 ;
14232 int val3 ;
14233 int ecode3 = 0 ;
14234 int val4 ;
14235 int ecode4 = 0 ;
14236 PyObject * obj0 = 0 ;
14237 PyObject * obj1 = 0 ;
14238 PyObject * obj2 = 0 ;
14239 PyObject * obj3 = 0 ;
14240 char * kwnames[] = {
14241 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
14242 };
14243
14244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14246 if (!SWIG_IsOK(res1)) {
14247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
14248 }
14249 arg1 = reinterpret_cast< wxImage * >(argp1);
14250 ecode2 = SWIG_AsVal_int(obj1, &val2);
14251 if (!SWIG_IsOK(ecode2)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
14253 }
14254 arg2 = static_cast< int >(val2);
14255 ecode3 = SWIG_AsVal_int(obj2, &val3);
14256 if (!SWIG_IsOK(ecode3)) {
14257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
14258 }
14259 arg3 = static_cast< int >(val3);
14260 if (obj3) {
14261 ecode4 = SWIG_AsVal_int(obj3, &val4);
14262 if (!SWIG_IsOK(ecode4)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
14264 }
14265 arg4 = static_cast< int >(val4);
14266 }
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 {
14270 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
14271 result = (wxImage *) &_result_ref;
14272 }
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14277 return resultobj;
14278 fail:
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14284 PyObject *resultobj = 0;
14285 wxImage *arg1 = (wxImage *) 0 ;
14286 wxSize *arg2 = 0 ;
14287 wxPoint *arg3 = 0 ;
14288 int arg4 = (int) -1 ;
14289 int arg5 = (int) -1 ;
14290 int arg6 = (int) -1 ;
14291 wxImage *result = 0 ;
14292 void *argp1 = 0 ;
14293 int res1 = 0 ;
14294 wxSize temp2 ;
14295 wxPoint temp3 ;
14296 int val4 ;
14297 int ecode4 = 0 ;
14298 int val5 ;
14299 int ecode5 = 0 ;
14300 int val6 ;
14301 int ecode6 = 0 ;
14302 PyObject * obj0 = 0 ;
14303 PyObject * obj1 = 0 ;
14304 PyObject * obj2 = 0 ;
14305 PyObject * obj3 = 0 ;
14306 PyObject * obj4 = 0 ;
14307 PyObject * obj5 = 0 ;
14308 char * kwnames[] = {
14309 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
14310 };
14311
14312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14314 if (!SWIG_IsOK(res1)) {
14315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
14316 }
14317 arg1 = reinterpret_cast< wxImage * >(argp1);
14318 {
14319 arg2 = &temp2;
14320 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
14321 }
14322 {
14323 arg3 = &temp3;
14324 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
14325 }
14326 if (obj3) {
14327 ecode4 = SWIG_AsVal_int(obj3, &val4);
14328 if (!SWIG_IsOK(ecode4)) {
14329 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
14330 }
14331 arg4 = static_cast< int >(val4);
14332 }
14333 if (obj4) {
14334 ecode5 = SWIG_AsVal_int(obj4, &val5);
14335 if (!SWIG_IsOK(ecode5)) {
14336 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
14337 }
14338 arg5 = static_cast< int >(val5);
14339 }
14340 if (obj5) {
14341 ecode6 = SWIG_AsVal_int(obj5, &val6);
14342 if (!SWIG_IsOK(ecode6)) {
14343 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
14344 }
14345 arg6 = static_cast< int >(val6);
14346 }
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 {
14350 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
14351 result = (wxImage *) &_result_ref;
14352 }
14353 wxPyEndAllowThreads(__tstate);
14354 if (PyErr_Occurred()) SWIG_fail;
14355 }
14356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj = 0;
14365 wxImage *arg1 = (wxImage *) 0 ;
14366 int arg2 ;
14367 int arg3 ;
14368 byte arg4 ;
14369 byte arg5 ;
14370 byte arg6 ;
14371 void *argp1 = 0 ;
14372 int res1 = 0 ;
14373 int val2 ;
14374 int ecode2 = 0 ;
14375 int val3 ;
14376 int ecode3 = 0 ;
14377 unsigned char val4 ;
14378 int ecode4 = 0 ;
14379 unsigned char val5 ;
14380 int ecode5 = 0 ;
14381 unsigned char val6 ;
14382 int ecode6 = 0 ;
14383 PyObject * obj0 = 0 ;
14384 PyObject * obj1 = 0 ;
14385 PyObject * obj2 = 0 ;
14386 PyObject * obj3 = 0 ;
14387 PyObject * obj4 = 0 ;
14388 PyObject * obj5 = 0 ;
14389 char * kwnames[] = {
14390 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14391 };
14392
14393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14395 if (!SWIG_IsOK(res1)) {
14396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14397 }
14398 arg1 = reinterpret_cast< wxImage * >(argp1);
14399 ecode2 = SWIG_AsVal_int(obj1, &val2);
14400 if (!SWIG_IsOK(ecode2)) {
14401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14402 }
14403 arg2 = static_cast< int >(val2);
14404 ecode3 = SWIG_AsVal_int(obj2, &val3);
14405 if (!SWIG_IsOK(ecode3)) {
14406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14407 }
14408 arg3 = static_cast< int >(val3);
14409 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14410 if (!SWIG_IsOK(ecode4)) {
14411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14412 }
14413 arg4 = static_cast< byte >(val4);
14414 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14415 if (!SWIG_IsOK(ecode5)) {
14416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14417 }
14418 arg5 = static_cast< byte >(val5);
14419 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14420 if (!SWIG_IsOK(ecode6)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14422 }
14423 arg6 = static_cast< byte >(val6);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 resultobj = SWIG_Py_Void();
14431 return resultobj;
14432 fail:
14433 return NULL;
14434 }
14435
14436
14437 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14438 PyObject *resultobj = 0;
14439 wxImage *arg1 = (wxImage *) 0 ;
14440 wxRect *arg2 = 0 ;
14441 byte arg3 ;
14442 byte arg4 ;
14443 byte arg5 ;
14444 void *argp1 = 0 ;
14445 int res1 = 0 ;
14446 wxRect temp2 ;
14447 unsigned char val3 ;
14448 int ecode3 = 0 ;
14449 unsigned char val4 ;
14450 int ecode4 = 0 ;
14451 unsigned char val5 ;
14452 int ecode5 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 PyObject * obj3 = 0 ;
14457 PyObject * obj4 = 0 ;
14458 char * kwnames[] = {
14459 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14460 };
14461
14462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14464 if (!SWIG_IsOK(res1)) {
14465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14466 }
14467 arg1 = reinterpret_cast< wxImage * >(argp1);
14468 {
14469 arg2 = &temp2;
14470 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14471 }
14472 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14473 if (!SWIG_IsOK(ecode3)) {
14474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14475 }
14476 arg3 = static_cast< byte >(val3);
14477 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14478 if (!SWIG_IsOK(ecode4)) {
14479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14480 }
14481 arg4 = static_cast< byte >(val4);
14482 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14483 if (!SWIG_IsOK(ecode5)) {
14484 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14485 }
14486 arg5 = static_cast< byte >(val5);
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 resultobj = SWIG_Py_Void();
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj = 0;
14502 wxImage *arg1 = (wxImage *) 0 ;
14503 int arg2 ;
14504 int arg3 ;
14505 byte result;
14506 void *argp1 = 0 ;
14507 int res1 = 0 ;
14508 int val2 ;
14509 int ecode2 = 0 ;
14510 int val3 ;
14511 int ecode3 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 char * kwnames[] = {
14516 (char *) "self",(char *) "x",(char *) "y", NULL
14517 };
14518
14519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14521 if (!SWIG_IsOK(res1)) {
14522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14523 }
14524 arg1 = reinterpret_cast< wxImage * >(argp1);
14525 ecode2 = SWIG_AsVal_int(obj1, &val2);
14526 if (!SWIG_IsOK(ecode2)) {
14527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14528 }
14529 arg2 = static_cast< int >(val2);
14530 ecode3 = SWIG_AsVal_int(obj2, &val3);
14531 if (!SWIG_IsOK(ecode3)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14533 }
14534 arg3 = static_cast< int >(val3);
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 result = (byte)(arg1)->GetRed(arg2,arg3);
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14542 return resultobj;
14543 fail:
14544 return NULL;
14545 }
14546
14547
14548 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14549 PyObject *resultobj = 0;
14550 wxImage *arg1 = (wxImage *) 0 ;
14551 int arg2 ;
14552 int arg3 ;
14553 byte result;
14554 void *argp1 = 0 ;
14555 int res1 = 0 ;
14556 int val2 ;
14557 int ecode2 = 0 ;
14558 int val3 ;
14559 int ecode3 = 0 ;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 PyObject * obj2 = 0 ;
14563 char * kwnames[] = {
14564 (char *) "self",(char *) "x",(char *) "y", NULL
14565 };
14566
14567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14569 if (!SWIG_IsOK(res1)) {
14570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14571 }
14572 arg1 = reinterpret_cast< wxImage * >(argp1);
14573 ecode2 = SWIG_AsVal_int(obj1, &val2);
14574 if (!SWIG_IsOK(ecode2)) {
14575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14576 }
14577 arg2 = static_cast< int >(val2);
14578 ecode3 = SWIG_AsVal_int(obj2, &val3);
14579 if (!SWIG_IsOK(ecode3)) {
14580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14581 }
14582 arg3 = static_cast< int >(val3);
14583 {
14584 PyThreadState* __tstate = wxPyBeginAllowThreads();
14585 result = (byte)(arg1)->GetGreen(arg2,arg3);
14586 wxPyEndAllowThreads(__tstate);
14587 if (PyErr_Occurred()) SWIG_fail;
14588 }
14589 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14590 return resultobj;
14591 fail:
14592 return NULL;
14593 }
14594
14595
14596 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14597 PyObject *resultobj = 0;
14598 wxImage *arg1 = (wxImage *) 0 ;
14599 int arg2 ;
14600 int arg3 ;
14601 byte result;
14602 void *argp1 = 0 ;
14603 int res1 = 0 ;
14604 int val2 ;
14605 int ecode2 = 0 ;
14606 int val3 ;
14607 int ecode3 = 0 ;
14608 PyObject * obj0 = 0 ;
14609 PyObject * obj1 = 0 ;
14610 PyObject * obj2 = 0 ;
14611 char * kwnames[] = {
14612 (char *) "self",(char *) "x",(char *) "y", NULL
14613 };
14614
14615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14619 }
14620 arg1 = reinterpret_cast< wxImage * >(argp1);
14621 ecode2 = SWIG_AsVal_int(obj1, &val2);
14622 if (!SWIG_IsOK(ecode2)) {
14623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14624 }
14625 arg2 = static_cast< int >(val2);
14626 ecode3 = SWIG_AsVal_int(obj2, &val3);
14627 if (!SWIG_IsOK(ecode3)) {
14628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14629 }
14630 arg3 = static_cast< int >(val3);
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 result = (byte)(arg1)->GetBlue(arg2,arg3);
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxImage *arg1 = (wxImage *) 0 ;
14647 int arg2 ;
14648 int arg3 ;
14649 byte arg4 ;
14650 void *argp1 = 0 ;
14651 int res1 = 0 ;
14652 int val2 ;
14653 int ecode2 = 0 ;
14654 int val3 ;
14655 int ecode3 = 0 ;
14656 unsigned char val4 ;
14657 int ecode4 = 0 ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 PyObject * obj2 = 0 ;
14661 PyObject * obj3 = 0 ;
14662 char * kwnames[] = {
14663 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14664 };
14665
14666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14670 }
14671 arg1 = reinterpret_cast< wxImage * >(argp1);
14672 ecode2 = SWIG_AsVal_int(obj1, &val2);
14673 if (!SWIG_IsOK(ecode2)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14675 }
14676 arg2 = static_cast< int >(val2);
14677 ecode3 = SWIG_AsVal_int(obj2, &val3);
14678 if (!SWIG_IsOK(ecode3)) {
14679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14680 }
14681 arg3 = static_cast< int >(val3);
14682 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14683 if (!SWIG_IsOK(ecode4)) {
14684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14685 }
14686 arg4 = static_cast< byte >(val4);
14687 {
14688 PyThreadState* __tstate = wxPyBeginAllowThreads();
14689 (arg1)->SetAlpha(arg2,arg3,arg4);
14690 wxPyEndAllowThreads(__tstate);
14691 if (PyErr_Occurred()) SWIG_fail;
14692 }
14693 resultobj = SWIG_Py_Void();
14694 return resultobj;
14695 fail:
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj = 0;
14702 wxImage *arg1 = (wxImage *) 0 ;
14703 int arg2 ;
14704 int arg3 ;
14705 byte result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 int val2 ;
14709 int ecode2 = 0 ;
14710 int val3 ;
14711 int ecode3 = 0 ;
14712 PyObject * obj0 = 0 ;
14713 PyObject * obj1 = 0 ;
14714 PyObject * obj2 = 0 ;
14715 char * kwnames[] = {
14716 (char *) "self",(char *) "x",(char *) "y", NULL
14717 };
14718
14719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14721 if (!SWIG_IsOK(res1)) {
14722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14723 }
14724 arg1 = reinterpret_cast< wxImage * >(argp1);
14725 ecode2 = SWIG_AsVal_int(obj1, &val2);
14726 if (!SWIG_IsOK(ecode2)) {
14727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14728 }
14729 arg2 = static_cast< int >(val2);
14730 ecode3 = SWIG_AsVal_int(obj2, &val3);
14731 if (!SWIG_IsOK(ecode3)) {
14732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14733 }
14734 arg3 = static_cast< int >(val3);
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14749 PyObject *resultobj = 0;
14750 wxImage *arg1 = (wxImage *) 0 ;
14751 bool result;
14752 void *argp1 = 0 ;
14753 int res1 = 0 ;
14754 PyObject *swig_obj[1] ;
14755
14756 if (!args) SWIG_fail;
14757 swig_obj[0] = args;
14758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14761 }
14762 arg1 = reinterpret_cast< wxImage * >(argp1);
14763 {
14764 PyThreadState* __tstate = wxPyBeginAllowThreads();
14765 result = (bool)(arg1)->HasAlpha();
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 {
14770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14771 }
14772 return resultobj;
14773 fail:
14774 return NULL;
14775 }
14776
14777
14778 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14779 PyObject *resultobj = 0;
14780 wxImage *arg1 = (wxImage *) 0 ;
14781 void *argp1 = 0 ;
14782 int res1 = 0 ;
14783 PyObject *swig_obj[1] ;
14784
14785 if (!args) SWIG_fail;
14786 swig_obj[0] = args;
14787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14788 if (!SWIG_IsOK(res1)) {
14789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14790 }
14791 arg1 = reinterpret_cast< wxImage * >(argp1);
14792 {
14793 PyThreadState* __tstate = wxPyBeginAllowThreads();
14794 (arg1)->InitAlpha();
14795 wxPyEndAllowThreads(__tstate);
14796 if (PyErr_Occurred()) SWIG_fail;
14797 }
14798 resultobj = SWIG_Py_Void();
14799 return resultobj;
14800 fail:
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj = 0;
14807 wxImage *arg1 = (wxImage *) 0 ;
14808 int arg2 ;
14809 int arg3 ;
14810 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14811 bool result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 int val2 ;
14815 int ecode2 = 0 ;
14816 int val3 ;
14817 int ecode3 = 0 ;
14818 unsigned char val4 ;
14819 int ecode4 = 0 ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 PyObject * obj2 = 0 ;
14823 PyObject * obj3 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14826 };
14827
14828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14830 if (!SWIG_IsOK(res1)) {
14831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14832 }
14833 arg1 = reinterpret_cast< wxImage * >(argp1);
14834 ecode2 = SWIG_AsVal_int(obj1, &val2);
14835 if (!SWIG_IsOK(ecode2)) {
14836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14837 }
14838 arg2 = static_cast< int >(val2);
14839 ecode3 = SWIG_AsVal_int(obj2, &val3);
14840 if (!SWIG_IsOK(ecode3)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14842 }
14843 arg3 = static_cast< int >(val3);
14844 if (obj3) {
14845 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14846 if (!SWIG_IsOK(ecode4)) {
14847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14848 }
14849 arg4 = static_cast< byte >(val4);
14850 }
14851 {
14852 PyThreadState* __tstate = wxPyBeginAllowThreads();
14853 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14854 wxPyEndAllowThreads(__tstate);
14855 if (PyErr_Occurred()) SWIG_fail;
14856 }
14857 {
14858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14859 }
14860 return resultobj;
14861 fail:
14862 return NULL;
14863 }
14864
14865
14866 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14867 PyObject *resultobj = 0;
14868 wxImage *arg1 = (wxImage *) 0 ;
14869 byte *arg2 = (byte *) 0 ;
14870 byte *arg3 = (byte *) 0 ;
14871 byte *arg4 = (byte *) 0 ;
14872 byte arg5 = (byte) 0 ;
14873 byte arg6 = (byte) 0 ;
14874 byte arg7 = (byte) 0 ;
14875 bool result;
14876 void *argp1 = 0 ;
14877 int res1 = 0 ;
14878 byte temp2 ;
14879 int res2 = SWIG_TMPOBJ ;
14880 byte temp3 ;
14881 int res3 = SWIG_TMPOBJ ;
14882 byte temp4 ;
14883 int res4 = SWIG_TMPOBJ ;
14884 unsigned char val5 ;
14885 int ecode5 = 0 ;
14886 unsigned char val6 ;
14887 int ecode6 = 0 ;
14888 unsigned char val7 ;
14889 int ecode7 = 0 ;
14890 PyObject * obj0 = 0 ;
14891 PyObject * obj1 = 0 ;
14892 PyObject * obj2 = 0 ;
14893 PyObject * obj3 = 0 ;
14894 char * kwnames[] = {
14895 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14896 };
14897
14898 arg2 = &temp2;
14899 arg3 = &temp3;
14900 arg4 = &temp4;
14901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14905 }
14906 arg1 = reinterpret_cast< wxImage * >(argp1);
14907 if (obj1) {
14908 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14909 if (!SWIG_IsOK(ecode5)) {
14910 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14911 }
14912 arg5 = static_cast< byte >(val5);
14913 }
14914 if (obj2) {
14915 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14916 if (!SWIG_IsOK(ecode6)) {
14917 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14918 }
14919 arg6 = static_cast< byte >(val6);
14920 }
14921 if (obj3) {
14922 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14923 if (!SWIG_IsOK(ecode7)) {
14924 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14925 }
14926 arg7 = static_cast< byte >(val7);
14927 }
14928 {
14929 PyThreadState* __tstate = wxPyBeginAllowThreads();
14930 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 {
14935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14936 }
14937 if (SWIG_IsTmpObj(res2)) {
14938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14939 } else {
14940 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14942 }
14943 if (SWIG_IsTmpObj(res3)) {
14944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14945 } else {
14946 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14948 }
14949 if (SWIG_IsTmpObj(res4)) {
14950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14951 } else {
14952 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14954 }
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj = 0;
14963 wxImage *arg1 = (wxImage *) 0 ;
14964 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14965 bool result;
14966 void *argp1 = 0 ;
14967 int res1 = 0 ;
14968 unsigned char val2 ;
14969 int ecode2 = 0 ;
14970 PyObject * obj0 = 0 ;
14971 PyObject * obj1 = 0 ;
14972 char * kwnames[] = {
14973 (char *) "self",(char *) "threshold", NULL
14974 };
14975
14976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14978 if (!SWIG_IsOK(res1)) {
14979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14980 }
14981 arg1 = reinterpret_cast< wxImage * >(argp1);
14982 if (obj1) {
14983 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14984 if (!SWIG_IsOK(ecode2)) {
14985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14986 }
14987 arg2 = static_cast< byte >(val2);
14988 }
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 {
14996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14997 }
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj = 0;
15006 wxImage *arg1 = (wxImage *) 0 ;
15007 byte arg2 ;
15008 byte arg3 ;
15009 byte arg4 ;
15010 bool result;
15011 void *argp1 = 0 ;
15012 int res1 = 0 ;
15013 unsigned char val2 ;
15014 int ecode2 = 0 ;
15015 unsigned char val3 ;
15016 int ecode3 = 0 ;
15017 unsigned char val4 ;
15018 int ecode4 = 0 ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 PyObject * obj2 = 0 ;
15022 PyObject * obj3 = 0 ;
15023 char * kwnames[] = {
15024 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15025 };
15026
15027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15029 if (!SWIG_IsOK(res1)) {
15030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
15031 }
15032 arg1 = reinterpret_cast< wxImage * >(argp1);
15033 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15034 if (!SWIG_IsOK(ecode2)) {
15035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
15036 }
15037 arg2 = static_cast< byte >(val2);
15038 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15039 if (!SWIG_IsOK(ecode3)) {
15040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
15041 }
15042 arg3 = static_cast< byte >(val3);
15043 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15044 if (!SWIG_IsOK(ecode4)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
15046 }
15047 arg4 = static_cast< byte >(val4);
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 {
15055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15056 }
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15064 PyObject *resultobj = 0;
15065 wxImage *arg1 = (wxImage *) 0 ;
15066 wxImage *arg2 = 0 ;
15067 byte arg3 ;
15068 byte arg4 ;
15069 byte arg5 ;
15070 bool result;
15071 void *argp1 = 0 ;
15072 int res1 = 0 ;
15073 void *argp2 = 0 ;
15074 int res2 = 0 ;
15075 unsigned char val3 ;
15076 int ecode3 = 0 ;
15077 unsigned char val4 ;
15078 int ecode4 = 0 ;
15079 unsigned char val5 ;
15080 int ecode5 = 0 ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 PyObject * obj2 = 0 ;
15084 PyObject * obj3 = 0 ;
15085 PyObject * obj4 = 0 ;
15086 char * kwnames[] = {
15087 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
15088 };
15089
15090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15092 if (!SWIG_IsOK(res1)) {
15093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
15094 }
15095 arg1 = reinterpret_cast< wxImage * >(argp1);
15096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15097 if (!SWIG_IsOK(res2)) {
15098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15099 }
15100 if (!argp2) {
15101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
15102 }
15103 arg2 = reinterpret_cast< wxImage * >(argp2);
15104 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15105 if (!SWIG_IsOK(ecode3)) {
15106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
15107 }
15108 arg3 = static_cast< byte >(val3);
15109 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15110 if (!SWIG_IsOK(ecode4)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
15112 }
15113 arg4 = static_cast< byte >(val4);
15114 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15115 if (!SWIG_IsOK(ecode5)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
15117 }
15118 arg5 = static_cast< byte >(val5);
15119 {
15120 PyThreadState* __tstate = wxPyBeginAllowThreads();
15121 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
15122 wxPyEndAllowThreads(__tstate);
15123 if (PyErr_Occurred()) SWIG_fail;
15124 }
15125 {
15126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15127 }
15128 return resultobj;
15129 fail:
15130 return NULL;
15131 }
15132
15133
15134 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj = 0;
15136 wxString *arg1 = 0 ;
15137 bool result;
15138 bool temp1 = false ;
15139 PyObject * obj0 = 0 ;
15140 char * kwnames[] = {
15141 (char *) "filename", NULL
15142 };
15143
15144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
15145 {
15146 arg1 = wxString_in_helper(obj0);
15147 if (arg1 == NULL) SWIG_fail;
15148 temp1 = true;
15149 }
15150 {
15151 PyThreadState* __tstate = wxPyBeginAllowThreads();
15152 result = (bool)wxImage::CanRead((wxString const &)*arg1);
15153 wxPyEndAllowThreads(__tstate);
15154 if (PyErr_Occurred()) SWIG_fail;
15155 }
15156 {
15157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15158 }
15159 {
15160 if (temp1)
15161 delete arg1;
15162 }
15163 return resultobj;
15164 fail:
15165 {
15166 if (temp1)
15167 delete arg1;
15168 }
15169 return NULL;
15170 }
15171
15172
15173 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15174 PyObject *resultobj = 0;
15175 wxString *arg1 = 0 ;
15176 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15177 int result;
15178 bool temp1 = false ;
15179 long val2 ;
15180 int ecode2 = 0 ;
15181 PyObject * obj0 = 0 ;
15182 PyObject * obj1 = 0 ;
15183 char * kwnames[] = {
15184 (char *) "filename",(char *) "type", NULL
15185 };
15186
15187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
15188 {
15189 arg1 = wxString_in_helper(obj0);
15190 if (arg1 == NULL) SWIG_fail;
15191 temp1 = true;
15192 }
15193 if (obj1) {
15194 ecode2 = SWIG_AsVal_long(obj1, &val2);
15195 if (!SWIG_IsOK(ecode2)) {
15196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
15197 }
15198 arg2 = static_cast< long >(val2);
15199 }
15200 {
15201 PyThreadState* __tstate = wxPyBeginAllowThreads();
15202 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
15203 wxPyEndAllowThreads(__tstate);
15204 if (PyErr_Occurred()) SWIG_fail;
15205 }
15206 resultobj = SWIG_From_int(static_cast< int >(result));
15207 {
15208 if (temp1)
15209 delete arg1;
15210 }
15211 return resultobj;
15212 fail:
15213 {
15214 if (temp1)
15215 delete arg1;
15216 }
15217 return NULL;
15218 }
15219
15220
15221 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = 0;
15223 wxImage *arg1 = (wxImage *) 0 ;
15224 wxString *arg2 = 0 ;
15225 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15226 int arg4 = (int) -1 ;
15227 bool result;
15228 void *argp1 = 0 ;
15229 int res1 = 0 ;
15230 bool temp2 = false ;
15231 long val3 ;
15232 int ecode3 = 0 ;
15233 int val4 ;
15234 int ecode4 = 0 ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 PyObject * obj2 = 0 ;
15238 PyObject * obj3 = 0 ;
15239 char * kwnames[] = {
15240 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
15241 };
15242
15243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15245 if (!SWIG_IsOK(res1)) {
15246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
15247 }
15248 arg1 = reinterpret_cast< wxImage * >(argp1);
15249 {
15250 arg2 = wxString_in_helper(obj1);
15251 if (arg2 == NULL) SWIG_fail;
15252 temp2 = true;
15253 }
15254 if (obj2) {
15255 ecode3 = SWIG_AsVal_long(obj2, &val3);
15256 if (!SWIG_IsOK(ecode3)) {
15257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
15258 }
15259 arg3 = static_cast< long >(val3);
15260 }
15261 if (obj3) {
15262 ecode4 = SWIG_AsVal_int(obj3, &val4);
15263 if (!SWIG_IsOK(ecode4)) {
15264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
15265 }
15266 arg4 = static_cast< int >(val4);
15267 }
15268 {
15269 PyThreadState* __tstate = wxPyBeginAllowThreads();
15270 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
15271 wxPyEndAllowThreads(__tstate);
15272 if (PyErr_Occurred()) SWIG_fail;
15273 }
15274 {
15275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15276 }
15277 {
15278 if (temp2)
15279 delete arg2;
15280 }
15281 return resultobj;
15282 fail:
15283 {
15284 if (temp2)
15285 delete arg2;
15286 }
15287 return NULL;
15288 }
15289
15290
15291 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj = 0;
15293 wxImage *arg1 = (wxImage *) 0 ;
15294 wxString *arg2 = 0 ;
15295 wxString *arg3 = 0 ;
15296 int arg4 = (int) -1 ;
15297 bool result;
15298 void *argp1 = 0 ;
15299 int res1 = 0 ;
15300 bool temp2 = false ;
15301 bool temp3 = false ;
15302 int val4 ;
15303 int ecode4 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 PyObject * obj2 = 0 ;
15307 PyObject * obj3 = 0 ;
15308 char * kwnames[] = {
15309 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
15310 };
15311
15312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15316 }
15317 arg1 = reinterpret_cast< wxImage * >(argp1);
15318 {
15319 arg2 = wxString_in_helper(obj1);
15320 if (arg2 == NULL) SWIG_fail;
15321 temp2 = true;
15322 }
15323 {
15324 arg3 = wxString_in_helper(obj2);
15325 if (arg3 == NULL) SWIG_fail;
15326 temp3 = true;
15327 }
15328 if (obj3) {
15329 ecode4 = SWIG_AsVal_int(obj3, &val4);
15330 if (!SWIG_IsOK(ecode4)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
15332 }
15333 arg4 = static_cast< int >(val4);
15334 }
15335 {
15336 PyThreadState* __tstate = wxPyBeginAllowThreads();
15337 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 {
15342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15343 }
15344 {
15345 if (temp2)
15346 delete arg2;
15347 }
15348 {
15349 if (temp3)
15350 delete arg3;
15351 }
15352 return resultobj;
15353 fail:
15354 {
15355 if (temp2)
15356 delete arg2;
15357 }
15358 {
15359 if (temp3)
15360 delete arg3;
15361 }
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj = 0;
15368 wxImage *arg1 = (wxImage *) 0 ;
15369 wxString *arg2 = 0 ;
15370 int arg3 ;
15371 bool result;
15372 void *argp1 = 0 ;
15373 int res1 = 0 ;
15374 bool temp2 = false ;
15375 int val3 ;
15376 int ecode3 = 0 ;
15377 PyObject * obj0 = 0 ;
15378 PyObject * obj1 = 0 ;
15379 PyObject * obj2 = 0 ;
15380 char * kwnames[] = {
15381 (char *) "self",(char *) "name",(char *) "type", NULL
15382 };
15383
15384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15386 if (!SWIG_IsOK(res1)) {
15387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15388 }
15389 arg1 = reinterpret_cast< wxImage * >(argp1);
15390 {
15391 arg2 = wxString_in_helper(obj1);
15392 if (arg2 == NULL) SWIG_fail;
15393 temp2 = true;
15394 }
15395 ecode3 = SWIG_AsVal_int(obj2, &val3);
15396 if (!SWIG_IsOK(ecode3)) {
15397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15398 }
15399 arg3 = static_cast< int >(val3);
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 {
15407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15408 }
15409 {
15410 if (temp2)
15411 delete arg2;
15412 }
15413 return resultobj;
15414 fail:
15415 {
15416 if (temp2)
15417 delete arg2;
15418 }
15419 return NULL;
15420 }
15421
15422
15423 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15424 PyObject *resultobj = 0;
15425 wxImage *arg1 = (wxImage *) 0 ;
15426 wxString *arg2 = 0 ;
15427 wxString *arg3 = 0 ;
15428 bool result;
15429 void *argp1 = 0 ;
15430 int res1 = 0 ;
15431 bool temp2 = false ;
15432 bool temp3 = false ;
15433 PyObject * obj0 = 0 ;
15434 PyObject * obj1 = 0 ;
15435 PyObject * obj2 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 arg2 = wxString_in_helper(obj1);
15448 if (arg2 == NULL) SWIG_fail;
15449 temp2 = true;
15450 }
15451 {
15452 arg3 = wxString_in_helper(obj2);
15453 if (arg3 == NULL) SWIG_fail;
15454 temp3 = true;
15455 }
15456 {
15457 PyThreadState* __tstate = wxPyBeginAllowThreads();
15458 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15459 wxPyEndAllowThreads(__tstate);
15460 if (PyErr_Occurred()) SWIG_fail;
15461 }
15462 {
15463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15464 }
15465 {
15466 if (temp2)
15467 delete arg2;
15468 }
15469 {
15470 if (temp3)
15471 delete arg3;
15472 }
15473 return resultobj;
15474 fail:
15475 {
15476 if (temp2)
15477 delete arg2;
15478 }
15479 {
15480 if (temp3)
15481 delete arg3;
15482 }
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxInputStream *arg1 = 0 ;
15490 bool result;
15491 wxPyInputStream *temp1 ;
15492 bool created1 ;
15493 PyObject * obj0 = 0 ;
15494 char * kwnames[] = {
15495 (char *) "stream", NULL
15496 };
15497
15498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15499 {
15500 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15501 arg1 = temp1->m_wxis;
15502 created1 = false;
15503 } else {
15504 PyErr_Clear(); // clear the failure of the wxPyConvert above
15505 arg1 = wxPyCBInputStream_create(obj0, false);
15506 if (arg1 == NULL) {
15507 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15508 SWIG_fail;
15509 }
15510 created1 = true;
15511 }
15512 }
15513 {
15514 PyThreadState* __tstate = wxPyBeginAllowThreads();
15515 result = (bool)wxImage::CanRead(*arg1);
15516 wxPyEndAllowThreads(__tstate);
15517 if (PyErr_Occurred()) SWIG_fail;
15518 }
15519 {
15520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15521 }
15522 {
15523 if (created1) delete arg1;
15524 }
15525 return resultobj;
15526 fail:
15527 {
15528 if (created1) delete arg1;
15529 }
15530 return NULL;
15531 }
15532
15533
15534 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15535 PyObject *resultobj = 0;
15536 wxImage *arg1 = (wxImage *) 0 ;
15537 wxInputStream *arg2 = 0 ;
15538 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15539 int arg4 = (int) -1 ;
15540 bool result;
15541 void *argp1 = 0 ;
15542 int res1 = 0 ;
15543 wxPyInputStream *temp2 ;
15544 bool created2 ;
15545 long val3 ;
15546 int ecode3 = 0 ;
15547 int val4 ;
15548 int ecode4 = 0 ;
15549 PyObject * obj0 = 0 ;
15550 PyObject * obj1 = 0 ;
15551 PyObject * obj2 = 0 ;
15552 PyObject * obj3 = 0 ;
15553 char * kwnames[] = {
15554 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15555 };
15556
15557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15559 if (!SWIG_IsOK(res1)) {
15560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15561 }
15562 arg1 = reinterpret_cast< wxImage * >(argp1);
15563 {
15564 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15565 arg2 = temp2->m_wxis;
15566 created2 = false;
15567 } else {
15568 PyErr_Clear(); // clear the failure of the wxPyConvert above
15569 arg2 = wxPyCBInputStream_create(obj1, false);
15570 if (arg2 == NULL) {
15571 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15572 SWIG_fail;
15573 }
15574 created2 = true;
15575 }
15576 }
15577 if (obj2) {
15578 ecode3 = SWIG_AsVal_long(obj2, &val3);
15579 if (!SWIG_IsOK(ecode3)) {
15580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15581 }
15582 arg3 = static_cast< long >(val3);
15583 }
15584 if (obj3) {
15585 ecode4 = SWIG_AsVal_int(obj3, &val4);
15586 if (!SWIG_IsOK(ecode4)) {
15587 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15588 }
15589 arg4 = static_cast< int >(val4);
15590 }
15591 {
15592 PyThreadState* __tstate = wxPyBeginAllowThreads();
15593 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15594 wxPyEndAllowThreads(__tstate);
15595 if (PyErr_Occurred()) SWIG_fail;
15596 }
15597 {
15598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15599 }
15600 {
15601 if (created2) delete arg2;
15602 }
15603 return resultobj;
15604 fail:
15605 {
15606 if (created2) delete arg2;
15607 }
15608 return NULL;
15609 }
15610
15611
15612 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15613 PyObject *resultobj = 0;
15614 wxImage *arg1 = (wxImage *) 0 ;
15615 wxInputStream *arg2 = 0 ;
15616 wxString *arg3 = 0 ;
15617 int arg4 = (int) -1 ;
15618 bool result;
15619 void *argp1 = 0 ;
15620 int res1 = 0 ;
15621 wxPyInputStream *temp2 ;
15622 bool created2 ;
15623 bool temp3 = false ;
15624 int val4 ;
15625 int ecode4 = 0 ;
15626 PyObject * obj0 = 0 ;
15627 PyObject * obj1 = 0 ;
15628 PyObject * obj2 = 0 ;
15629 PyObject * obj3 = 0 ;
15630 char * kwnames[] = {
15631 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15632 };
15633
15634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15636 if (!SWIG_IsOK(res1)) {
15637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15638 }
15639 arg1 = reinterpret_cast< wxImage * >(argp1);
15640 {
15641 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15642 arg2 = temp2->m_wxis;
15643 created2 = false;
15644 } else {
15645 PyErr_Clear(); // clear the failure of the wxPyConvert above
15646 arg2 = wxPyCBInputStream_create(obj1, false);
15647 if (arg2 == NULL) {
15648 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15649 SWIG_fail;
15650 }
15651 created2 = true;
15652 }
15653 }
15654 {
15655 arg3 = wxString_in_helper(obj2);
15656 if (arg3 == NULL) SWIG_fail;
15657 temp3 = true;
15658 }
15659 if (obj3) {
15660 ecode4 = SWIG_AsVal_int(obj3, &val4);
15661 if (!SWIG_IsOK(ecode4)) {
15662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15663 }
15664 arg4 = static_cast< int >(val4);
15665 }
15666 {
15667 PyThreadState* __tstate = wxPyBeginAllowThreads();
15668 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15674 }
15675 {
15676 if (created2) delete arg2;
15677 }
15678 {
15679 if (temp3)
15680 delete arg3;
15681 }
15682 return resultobj;
15683 fail:
15684 {
15685 if (created2) delete arg2;
15686 }
15687 {
15688 if (temp3)
15689 delete arg3;
15690 }
15691 return NULL;
15692 }
15693
15694
15695 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15696 PyObject *resultobj = 0;
15697 wxImage *arg1 = (wxImage *) 0 ;
15698 bool result;
15699 void *argp1 = 0 ;
15700 int res1 = 0 ;
15701 PyObject *swig_obj[1] ;
15702
15703 if (!args) SWIG_fail;
15704 swig_obj[0] = args;
15705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15706 if (!SWIG_IsOK(res1)) {
15707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
15708 }
15709 arg1 = reinterpret_cast< wxImage * >(argp1);
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (bool)(arg1)->IsOk();
15713 wxPyEndAllowThreads(__tstate);
15714 if (PyErr_Occurred()) SWIG_fail;
15715 }
15716 {
15717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15718 }
15719 return resultobj;
15720 fail:
15721 return NULL;
15722 }
15723
15724
15725 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15726 PyObject *resultobj = 0;
15727 wxImage *arg1 = (wxImage *) 0 ;
15728 int result;
15729 void *argp1 = 0 ;
15730 int res1 = 0 ;
15731 PyObject *swig_obj[1] ;
15732
15733 if (!args) SWIG_fail;
15734 swig_obj[0] = args;
15735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15736 if (!SWIG_IsOK(res1)) {
15737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15738 }
15739 arg1 = reinterpret_cast< wxImage * >(argp1);
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (int)(arg1)->GetWidth();
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_From_int(static_cast< int >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxImage *arg1 = (wxImage *) 0 ;
15756 int result;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 PyObject *swig_obj[1] ;
15760
15761 if (!args) SWIG_fail;
15762 swig_obj[0] = args;
15763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage * >(argp1);
15768 {
15769 PyThreadState* __tstate = wxPyBeginAllowThreads();
15770 result = (int)(arg1)->GetHeight();
15771 wxPyEndAllowThreads(__tstate);
15772 if (PyErr_Occurred()) SWIG_fail;
15773 }
15774 resultobj = SWIG_From_int(static_cast< int >(result));
15775 return resultobj;
15776 fail:
15777 return NULL;
15778 }
15779
15780
15781 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15782 PyObject *resultobj = 0;
15783 wxImage *arg1 = (wxImage *) 0 ;
15784 wxSize result;
15785 void *argp1 = 0 ;
15786 int res1 = 0 ;
15787 PyObject *swig_obj[1] ;
15788
15789 if (!args) SWIG_fail;
15790 swig_obj[0] = args;
15791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15792 if (!SWIG_IsOK(res1)) {
15793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15794 }
15795 arg1 = reinterpret_cast< wxImage * >(argp1);
15796 {
15797 PyThreadState* __tstate = wxPyBeginAllowThreads();
15798 result = wxImage_GetSize(arg1);
15799 wxPyEndAllowThreads(__tstate);
15800 if (PyErr_Occurred()) SWIG_fail;
15801 }
15802 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15803 return resultobj;
15804 fail:
15805 return NULL;
15806 }
15807
15808
15809 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15810 PyObject *resultobj = 0;
15811 wxImage *arg1 = (wxImage *) 0 ;
15812 wxRect *arg2 = 0 ;
15813 SwigValueWrapper<wxImage > result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 wxRect temp2 ;
15817 PyObject * obj0 = 0 ;
15818 PyObject * obj1 = 0 ;
15819 char * kwnames[] = {
15820 (char *) "self",(char *) "rect", NULL
15821 };
15822
15823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15827 }
15828 arg1 = reinterpret_cast< wxImage * >(argp1);
15829 {
15830 arg2 = &temp2;
15831 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 wxImage *arg1 = (wxImage *) 0 ;
15849 wxSize *arg2 = 0 ;
15850 wxPoint *arg3 = 0 ;
15851 int arg4 = (int) -1 ;
15852 int arg5 = (int) -1 ;
15853 int arg6 = (int) -1 ;
15854 SwigValueWrapper<wxImage > result;
15855 void *argp1 = 0 ;
15856 int res1 = 0 ;
15857 wxSize temp2 ;
15858 wxPoint temp3 ;
15859 int val4 ;
15860 int ecode4 = 0 ;
15861 int val5 ;
15862 int ecode5 = 0 ;
15863 int val6 ;
15864 int ecode6 = 0 ;
15865 PyObject * obj0 = 0 ;
15866 PyObject * obj1 = 0 ;
15867 PyObject * obj2 = 0 ;
15868 PyObject * obj3 = 0 ;
15869 PyObject * obj4 = 0 ;
15870 PyObject * obj5 = 0 ;
15871 char * kwnames[] = {
15872 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15873 };
15874
15875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15877 if (!SWIG_IsOK(res1)) {
15878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15879 }
15880 arg1 = reinterpret_cast< wxImage * >(argp1);
15881 {
15882 arg2 = &temp2;
15883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15884 }
15885 {
15886 arg3 = &temp3;
15887 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15888 }
15889 if (obj3) {
15890 ecode4 = SWIG_AsVal_int(obj3, &val4);
15891 if (!SWIG_IsOK(ecode4)) {
15892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15893 }
15894 arg4 = static_cast< int >(val4);
15895 }
15896 if (obj4) {
15897 ecode5 = SWIG_AsVal_int(obj4, &val5);
15898 if (!SWIG_IsOK(ecode5)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15900 }
15901 arg5 = static_cast< int >(val5);
15902 }
15903 if (obj5) {
15904 ecode6 = SWIG_AsVal_int(obj5, &val6);
15905 if (!SWIG_IsOK(ecode6)) {
15906 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15907 }
15908 arg6 = static_cast< int >(val6);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15924 PyObject *resultobj = 0;
15925 wxImage *arg1 = (wxImage *) 0 ;
15926 SwigValueWrapper<wxImage > result;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 PyObject *swig_obj[1] ;
15930
15931 if (!args) SWIG_fail;
15932 swig_obj[0] = args;
15933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15934 if (!SWIG_IsOK(res1)) {
15935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15936 }
15937 arg1 = reinterpret_cast< wxImage * >(argp1);
15938 {
15939 PyThreadState* __tstate = wxPyBeginAllowThreads();
15940 result = (arg1)->Copy();
15941 wxPyEndAllowThreads(__tstate);
15942 if (PyErr_Occurred()) SWIG_fail;
15943 }
15944 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15945 return resultobj;
15946 fail:
15947 return NULL;
15948 }
15949
15950
15951 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15952 PyObject *resultobj = 0;
15953 wxImage *arg1 = (wxImage *) 0 ;
15954 wxImage *arg2 = 0 ;
15955 int arg3 ;
15956 int arg4 ;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 void *argp2 = 0 ;
15960 int res2 = 0 ;
15961 int val3 ;
15962 int ecode3 = 0 ;
15963 int val4 ;
15964 int ecode4 = 0 ;
15965 PyObject * obj0 = 0 ;
15966 PyObject * obj1 = 0 ;
15967 PyObject * obj2 = 0 ;
15968 PyObject * obj3 = 0 ;
15969 char * kwnames[] = {
15970 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15971 };
15972
15973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15975 if (!SWIG_IsOK(res1)) {
15976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15977 }
15978 arg1 = reinterpret_cast< wxImage * >(argp1);
15979 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15980 if (!SWIG_IsOK(res2)) {
15981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15982 }
15983 if (!argp2) {
15984 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15985 }
15986 arg2 = reinterpret_cast< wxImage * >(argp2);
15987 ecode3 = SWIG_AsVal_int(obj2, &val3);
15988 if (!SWIG_IsOK(ecode3)) {
15989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15990 }
15991 arg3 = static_cast< int >(val3);
15992 ecode4 = SWIG_AsVal_int(obj3, &val4);
15993 if (!SWIG_IsOK(ecode4)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15995 }
15996 arg4 = static_cast< int >(val4);
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxImage *arg1 = (wxImage *) 0 ;
16013 PyObject *result = 0 ;
16014 void *argp1 = 0 ;
16015 int res1 = 0 ;
16016 PyObject *swig_obj[1] ;
16017
16018 if (!args) SWIG_fail;
16019 swig_obj[0] = args;
16020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16021 if (!SWIG_IsOK(res1)) {
16022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
16023 }
16024 arg1 = reinterpret_cast< wxImage * >(argp1);
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (PyObject *)wxImage_GetData(arg1);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = result;
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 buffer arg2 ;
16042 int arg3 ;
16043 void *argp1 = 0 ;
16044 int res1 = 0 ;
16045 Py_ssize_t temp2 ;
16046 PyObject * obj0 = 0 ;
16047 PyObject * obj1 = 0 ;
16048 char * kwnames[] = {
16049 (char *) "self",(char *) "data", NULL
16050 };
16051
16052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
16053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16054 if (!SWIG_IsOK(res1)) {
16055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
16056 }
16057 arg1 = reinterpret_cast< wxImage * >(argp1);
16058 {
16059 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16060 arg3 = (int)temp2;
16061 }
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 wxImage_SetData(arg1,arg2,arg3);
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 resultobj = SWIG_Py_Void();
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16076 PyObject *resultobj = 0;
16077 wxImage *arg1 = (wxImage *) 0 ;
16078 PyObject *result = 0 ;
16079 void *argp1 = 0 ;
16080 int res1 = 0 ;
16081 PyObject *swig_obj[1] ;
16082
16083 if (!args) SWIG_fail;
16084 swig_obj[0] = args;
16085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16086 if (!SWIG_IsOK(res1)) {
16087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16088 }
16089 arg1 = reinterpret_cast< wxImage * >(argp1);
16090 {
16091 PyThreadState* __tstate = wxPyBeginAllowThreads();
16092 result = (PyObject *)wxImage_GetDataBuffer(arg1);
16093 wxPyEndAllowThreads(__tstate);
16094 if (PyErr_Occurred()) SWIG_fail;
16095 }
16096 resultobj = result;
16097 return resultobj;
16098 fail:
16099 return NULL;
16100 }
16101
16102
16103 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16104 PyObject *resultobj = 0;
16105 wxImage *arg1 = (wxImage *) 0 ;
16106 buffer arg2 ;
16107 int arg3 ;
16108 void *argp1 = 0 ;
16109 int res1 = 0 ;
16110 Py_ssize_t temp2 ;
16111 PyObject * obj0 = 0 ;
16112 PyObject * obj1 = 0 ;
16113 char * kwnames[] = {
16114 (char *) "self",(char *) "data", NULL
16115 };
16116
16117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16119 if (!SWIG_IsOK(res1)) {
16120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16121 }
16122 arg1 = reinterpret_cast< wxImage * >(argp1);
16123 {
16124 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16125 arg3 = (int)temp2;
16126 }
16127 {
16128 PyThreadState* __tstate = wxPyBeginAllowThreads();
16129 wxImage_SetDataBuffer(arg1,arg2,arg3);
16130 wxPyEndAllowThreads(__tstate);
16131 if (PyErr_Occurred()) SWIG_fail;
16132 }
16133 resultobj = SWIG_Py_Void();
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16141 PyObject *resultobj = 0;
16142 wxImage *arg1 = (wxImage *) 0 ;
16143 PyObject *result = 0 ;
16144 void *argp1 = 0 ;
16145 int res1 = 0 ;
16146 PyObject *swig_obj[1] ;
16147
16148 if (!args) SWIG_fail;
16149 swig_obj[0] = args;
16150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16151 if (!SWIG_IsOK(res1)) {
16152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16153 }
16154 arg1 = reinterpret_cast< wxImage * >(argp1);
16155 {
16156 PyThreadState* __tstate = wxPyBeginAllowThreads();
16157 result = (PyObject *)wxImage_GetAlphaData(arg1);
16158 wxPyEndAllowThreads(__tstate);
16159 if (PyErr_Occurred()) SWIG_fail;
16160 }
16161 resultobj = result;
16162 return resultobj;
16163 fail:
16164 return NULL;
16165 }
16166
16167
16168 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16169 PyObject *resultobj = 0;
16170 wxImage *arg1 = (wxImage *) 0 ;
16171 buffer arg2 ;
16172 int arg3 ;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 Py_ssize_t temp2 ;
16176 PyObject * obj0 = 0 ;
16177 PyObject * obj1 = 0 ;
16178 char * kwnames[] = {
16179 (char *) "self",(char *) "alpha", NULL
16180 };
16181
16182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
16183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16184 if (!SWIG_IsOK(res1)) {
16185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
16186 }
16187 arg1 = reinterpret_cast< wxImage * >(argp1);
16188 {
16189 if (obj1 != Py_None) {
16190 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16191 arg3 = (int)temp2;
16192 }
16193 }
16194 {
16195 PyThreadState* __tstate = wxPyBeginAllowThreads();
16196 wxImage_SetAlphaData(arg1,arg2,arg3);
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_Py_Void();
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16208 PyObject *resultobj = 0;
16209 wxImage *arg1 = (wxImage *) 0 ;
16210 PyObject *result = 0 ;
16211 void *argp1 = 0 ;
16212 int res1 = 0 ;
16213 PyObject *swig_obj[1] ;
16214
16215 if (!args) SWIG_fail;
16216 swig_obj[0] = args;
16217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16218 if (!SWIG_IsOK(res1)) {
16219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16220 }
16221 arg1 = reinterpret_cast< wxImage * >(argp1);
16222 {
16223 PyThreadState* __tstate = wxPyBeginAllowThreads();
16224 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 resultobj = result;
16229 return resultobj;
16230 fail:
16231 return NULL;
16232 }
16233
16234
16235 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16236 PyObject *resultobj = 0;
16237 wxImage *arg1 = (wxImage *) 0 ;
16238 buffer arg2 ;
16239 int arg3 ;
16240 void *argp1 = 0 ;
16241 int res1 = 0 ;
16242 Py_ssize_t temp2 ;
16243 PyObject * obj0 = 0 ;
16244 PyObject * obj1 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "alpha", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
16253 }
16254 arg1 = reinterpret_cast< wxImage * >(argp1);
16255 {
16256 if (obj1 != Py_None) {
16257 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
16258 arg3 = (int)temp2;
16259 }
16260 }
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
16264 wxPyEndAllowThreads(__tstate);
16265 if (PyErr_Occurred()) SWIG_fail;
16266 }
16267 resultobj = SWIG_Py_Void();
16268 return resultobj;
16269 fail:
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxImage *arg1 = (wxImage *) 0 ;
16277 byte arg2 ;
16278 byte arg3 ;
16279 byte arg4 ;
16280 void *argp1 = 0 ;
16281 int res1 = 0 ;
16282 unsigned char val2 ;
16283 int ecode2 = 0 ;
16284 unsigned char val3 ;
16285 int ecode3 = 0 ;
16286 unsigned char val4 ;
16287 int ecode4 = 0 ;
16288 PyObject * obj0 = 0 ;
16289 PyObject * obj1 = 0 ;
16290 PyObject * obj2 = 0 ;
16291 PyObject * obj3 = 0 ;
16292 char * kwnames[] = {
16293 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16294 };
16295
16296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16298 if (!SWIG_IsOK(res1)) {
16299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
16300 }
16301 arg1 = reinterpret_cast< wxImage * >(argp1);
16302 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16303 if (!SWIG_IsOK(ecode2)) {
16304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
16305 }
16306 arg2 = static_cast< byte >(val2);
16307 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16308 if (!SWIG_IsOK(ecode3)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
16310 }
16311 arg3 = static_cast< byte >(val3);
16312 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16313 if (!SWIG_IsOK(ecode4)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
16315 }
16316 arg4 = static_cast< byte >(val4);
16317 {
16318 PyThreadState* __tstate = wxPyBeginAllowThreads();
16319 (arg1)->SetMaskColour(arg2,arg3,arg4);
16320 wxPyEndAllowThreads(__tstate);
16321 if (PyErr_Occurred()) SWIG_fail;
16322 }
16323 resultobj = SWIG_Py_Void();
16324 return resultobj;
16325 fail:
16326 return NULL;
16327 }
16328
16329
16330 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16331 PyObject *resultobj = 0;
16332 wxImage *arg1 = (wxImage *) 0 ;
16333 byte *arg2 = (byte *) 0 ;
16334 byte *arg3 = (byte *) 0 ;
16335 byte *arg4 = (byte *) 0 ;
16336 void *argp1 = 0 ;
16337 int res1 = 0 ;
16338 byte temp2 ;
16339 int res2 = SWIG_TMPOBJ ;
16340 byte temp3 ;
16341 int res3 = SWIG_TMPOBJ ;
16342 byte temp4 ;
16343 int res4 = SWIG_TMPOBJ ;
16344 PyObject *swig_obj[1] ;
16345
16346 arg2 = &temp2;
16347 arg3 = &temp3;
16348 arg4 = &temp4;
16349 if (!args) SWIG_fail;
16350 swig_obj[0] = args;
16351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16352 if (!SWIG_IsOK(res1)) {
16353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
16354 }
16355 arg1 = reinterpret_cast< wxImage * >(argp1);
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_Py_Void();
16363 if (SWIG_IsTmpObj(res2)) {
16364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16365 } else {
16366 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16368 }
16369 if (SWIG_IsTmpObj(res3)) {
16370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16371 } else {
16372 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16374 }
16375 if (SWIG_IsTmpObj(res4)) {
16376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16377 } else {
16378 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16380 }
16381 return resultobj;
16382 fail:
16383 return NULL;
16384 }
16385
16386
16387 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16388 PyObject *resultobj = 0;
16389 wxImage *arg1 = (wxImage *) 0 ;
16390 byte result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 PyObject *swig_obj[1] ;
16394
16395 if (!args) SWIG_fail;
16396 swig_obj[0] = args;
16397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16398 if (!SWIG_IsOK(res1)) {
16399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16400 }
16401 arg1 = reinterpret_cast< wxImage * >(argp1);
16402 {
16403 PyThreadState* __tstate = wxPyBeginAllowThreads();
16404 result = (byte)(arg1)->GetMaskRed();
16405 wxPyEndAllowThreads(__tstate);
16406 if (PyErr_Occurred()) SWIG_fail;
16407 }
16408 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16409 return resultobj;
16410 fail:
16411 return NULL;
16412 }
16413
16414
16415 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16416 PyObject *resultobj = 0;
16417 wxImage *arg1 = (wxImage *) 0 ;
16418 byte result;
16419 void *argp1 = 0 ;
16420 int res1 = 0 ;
16421 PyObject *swig_obj[1] ;
16422
16423 if (!args) SWIG_fail;
16424 swig_obj[0] = args;
16425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16426 if (!SWIG_IsOK(res1)) {
16427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16428 }
16429 arg1 = reinterpret_cast< wxImage * >(argp1);
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = (byte)(arg1)->GetMaskGreen();
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 byte result;
16447 void *argp1 = 0 ;
16448 int res1 = 0 ;
16449 PyObject *swig_obj[1] ;
16450
16451 if (!args) SWIG_fail;
16452 swig_obj[0] = args;
16453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16456 }
16457 arg1 = reinterpret_cast< wxImage * >(argp1);
16458 {
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (byte)(arg1)->GetMaskBlue();
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16465 return resultobj;
16466 fail:
16467 return NULL;
16468 }
16469
16470
16471 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16472 PyObject *resultobj = 0;
16473 wxImage *arg1 = (wxImage *) 0 ;
16474 bool arg2 = (bool) true ;
16475 void *argp1 = 0 ;
16476 int res1 = 0 ;
16477 bool val2 ;
16478 int ecode2 = 0 ;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 char * kwnames[] = {
16482 (char *) "self",(char *) "mask", NULL
16483 };
16484
16485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16487 if (!SWIG_IsOK(res1)) {
16488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16489 }
16490 arg1 = reinterpret_cast< wxImage * >(argp1);
16491 if (obj1) {
16492 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16493 if (!SWIG_IsOK(ecode2)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16495 }
16496 arg2 = static_cast< bool >(val2);
16497 }
16498 {
16499 PyThreadState* __tstate = wxPyBeginAllowThreads();
16500 (arg1)->SetMask(arg2);
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 resultobj = SWIG_Py_Void();
16505 return resultobj;
16506 fail:
16507 return NULL;
16508 }
16509
16510
16511 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16512 PyObject *resultobj = 0;
16513 wxImage *arg1 = (wxImage *) 0 ;
16514 bool result;
16515 void *argp1 = 0 ;
16516 int res1 = 0 ;
16517 PyObject *swig_obj[1] ;
16518
16519 if (!args) SWIG_fail;
16520 swig_obj[0] = args;
16521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16522 if (!SWIG_IsOK(res1)) {
16523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16524 }
16525 arg1 = reinterpret_cast< wxImage * >(argp1);
16526 {
16527 PyThreadState* __tstate = wxPyBeginAllowThreads();
16528 result = (bool)(arg1)->HasMask();
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 {
16533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16534 }
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = 0;
16543 wxImage *arg1 = (wxImage *) 0 ;
16544 double arg2 ;
16545 wxPoint *arg3 = 0 ;
16546 bool arg4 = (bool) true ;
16547 wxPoint *arg5 = (wxPoint *) NULL ;
16548 SwigValueWrapper<wxImage > result;
16549 void *argp1 = 0 ;
16550 int res1 = 0 ;
16551 double val2 ;
16552 int ecode2 = 0 ;
16553 wxPoint temp3 ;
16554 bool val4 ;
16555 int ecode4 = 0 ;
16556 void *argp5 = 0 ;
16557 int res5 = 0 ;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 PyObject * obj2 = 0 ;
16561 PyObject * obj3 = 0 ;
16562 PyObject * obj4 = 0 ;
16563 char * kwnames[] = {
16564 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16565 };
16566
16567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16569 if (!SWIG_IsOK(res1)) {
16570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16571 }
16572 arg1 = reinterpret_cast< wxImage * >(argp1);
16573 ecode2 = SWIG_AsVal_double(obj1, &val2);
16574 if (!SWIG_IsOK(ecode2)) {
16575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16576 }
16577 arg2 = static_cast< double >(val2);
16578 {
16579 arg3 = &temp3;
16580 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16581 }
16582 if (obj3) {
16583 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16584 if (!SWIG_IsOK(ecode4)) {
16585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16586 }
16587 arg4 = static_cast< bool >(val4);
16588 }
16589 if (obj4) {
16590 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16591 if (!SWIG_IsOK(res5)) {
16592 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16593 }
16594 arg5 = reinterpret_cast< wxPoint * >(argp5);
16595 }
16596 {
16597 PyThreadState* __tstate = wxPyBeginAllowThreads();
16598 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16599 wxPyEndAllowThreads(__tstate);
16600 if (PyErr_Occurred()) SWIG_fail;
16601 }
16602 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16603 return resultobj;
16604 fail:
16605 return NULL;
16606 }
16607
16608
16609 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16610 PyObject *resultobj = 0;
16611 wxImage *arg1 = (wxImage *) 0 ;
16612 bool arg2 = (bool) true ;
16613 SwigValueWrapper<wxImage > result;
16614 void *argp1 = 0 ;
16615 int res1 = 0 ;
16616 bool val2 ;
16617 int ecode2 = 0 ;
16618 PyObject * obj0 = 0 ;
16619 PyObject * obj1 = 0 ;
16620 char * kwnames[] = {
16621 (char *) "self",(char *) "clockwise", NULL
16622 };
16623
16624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16626 if (!SWIG_IsOK(res1)) {
16627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16628 }
16629 arg1 = reinterpret_cast< wxImage * >(argp1);
16630 if (obj1) {
16631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16632 if (!SWIG_IsOK(ecode2)) {
16633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16634 }
16635 arg2 = static_cast< bool >(val2);
16636 }
16637 {
16638 PyThreadState* __tstate = wxPyBeginAllowThreads();
16639 result = (arg1)->Rotate90(arg2);
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16644 return resultobj;
16645 fail:
16646 return NULL;
16647 }
16648
16649
16650 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16651 PyObject *resultobj = 0;
16652 wxImage *arg1 = (wxImage *) 0 ;
16653 bool arg2 = (bool) true ;
16654 SwigValueWrapper<wxImage > result;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 bool val2 ;
16658 int ecode2 = 0 ;
16659 PyObject * obj0 = 0 ;
16660 PyObject * obj1 = 0 ;
16661 char * kwnames[] = {
16662 (char *) "self",(char *) "horizontally", NULL
16663 };
16664
16665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16667 if (!SWIG_IsOK(res1)) {
16668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16669 }
16670 arg1 = reinterpret_cast< wxImage * >(argp1);
16671 if (obj1) {
16672 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16673 if (!SWIG_IsOK(ecode2)) {
16674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16675 }
16676 arg2 = static_cast< bool >(val2);
16677 }
16678 {
16679 PyThreadState* __tstate = wxPyBeginAllowThreads();
16680 result = (arg1)->Mirror(arg2);
16681 wxPyEndAllowThreads(__tstate);
16682 if (PyErr_Occurred()) SWIG_fail;
16683 }
16684 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16685 return resultobj;
16686 fail:
16687 return NULL;
16688 }
16689
16690
16691 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16692 PyObject *resultobj = 0;
16693 wxImage *arg1 = (wxImage *) 0 ;
16694 byte arg2 ;
16695 byte arg3 ;
16696 byte arg4 ;
16697 byte arg5 ;
16698 byte arg6 ;
16699 byte arg7 ;
16700 void *argp1 = 0 ;
16701 int res1 = 0 ;
16702 unsigned char val2 ;
16703 int ecode2 = 0 ;
16704 unsigned char val3 ;
16705 int ecode3 = 0 ;
16706 unsigned char val4 ;
16707 int ecode4 = 0 ;
16708 unsigned char val5 ;
16709 int ecode5 = 0 ;
16710 unsigned char val6 ;
16711 int ecode6 = 0 ;
16712 unsigned char val7 ;
16713 int ecode7 = 0 ;
16714 PyObject * obj0 = 0 ;
16715 PyObject * obj1 = 0 ;
16716 PyObject * obj2 = 0 ;
16717 PyObject * obj3 = 0 ;
16718 PyObject * obj4 = 0 ;
16719 PyObject * obj5 = 0 ;
16720 PyObject * obj6 = 0 ;
16721 char * kwnames[] = {
16722 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16723 };
16724
16725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16729 }
16730 arg1 = reinterpret_cast< wxImage * >(argp1);
16731 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16732 if (!SWIG_IsOK(ecode2)) {
16733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16734 }
16735 arg2 = static_cast< byte >(val2);
16736 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16737 if (!SWIG_IsOK(ecode3)) {
16738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16739 }
16740 arg3 = static_cast< byte >(val3);
16741 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16742 if (!SWIG_IsOK(ecode4)) {
16743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16744 }
16745 arg4 = static_cast< byte >(val4);
16746 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16747 if (!SWIG_IsOK(ecode5)) {
16748 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16749 }
16750 arg5 = static_cast< byte >(val5);
16751 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16752 if (!SWIG_IsOK(ecode6)) {
16753 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16754 }
16755 arg6 = static_cast< byte >(val6);
16756 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16757 if (!SWIG_IsOK(ecode7)) {
16758 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16759 }
16760 arg7 = static_cast< byte >(val7);
16761 {
16762 PyThreadState* __tstate = wxPyBeginAllowThreads();
16763 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 resultobj = SWIG_Py_Void();
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16775 PyObject *resultobj = 0;
16776 wxImage *arg1 = (wxImage *) 0 ;
16777 double arg2 = (double) 0.299 ;
16778 double arg3 = (double) 0.587 ;
16779 double arg4 = (double) 0.114 ;
16780 SwigValueWrapper<wxImage > result;
16781 void *argp1 = 0 ;
16782 int res1 = 0 ;
16783 double val2 ;
16784 int ecode2 = 0 ;
16785 double val3 ;
16786 int ecode3 = 0 ;
16787 double val4 ;
16788 int ecode4 = 0 ;
16789 PyObject * obj0 = 0 ;
16790 PyObject * obj1 = 0 ;
16791 PyObject * obj2 = 0 ;
16792 PyObject * obj3 = 0 ;
16793 char * kwnames[] = {
16794 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16795 };
16796
16797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16799 if (!SWIG_IsOK(res1)) {
16800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16801 }
16802 arg1 = reinterpret_cast< wxImage * >(argp1);
16803 if (obj1) {
16804 ecode2 = SWIG_AsVal_double(obj1, &val2);
16805 if (!SWIG_IsOK(ecode2)) {
16806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16807 }
16808 arg2 = static_cast< double >(val2);
16809 }
16810 if (obj2) {
16811 ecode3 = SWIG_AsVal_double(obj2, &val3);
16812 if (!SWIG_IsOK(ecode3)) {
16813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16814 }
16815 arg3 = static_cast< double >(val3);
16816 }
16817 if (obj3) {
16818 ecode4 = SWIG_AsVal_double(obj3, &val4);
16819 if (!SWIG_IsOK(ecode4)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16821 }
16822 arg4 = static_cast< double >(val4);
16823 }
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16827 wxPyEndAllowThreads(__tstate);
16828 if (PyErr_Occurred()) SWIG_fail;
16829 }
16830 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16831 return resultobj;
16832 fail:
16833 return NULL;
16834 }
16835
16836
16837 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16838 PyObject *resultobj = 0;
16839 wxImage *arg1 = (wxImage *) 0 ;
16840 byte arg2 ;
16841 byte arg3 ;
16842 byte arg4 ;
16843 SwigValueWrapper<wxImage > result;
16844 void *argp1 = 0 ;
16845 int res1 = 0 ;
16846 unsigned char val2 ;
16847 int ecode2 = 0 ;
16848 unsigned char val3 ;
16849 int ecode3 = 0 ;
16850 unsigned char val4 ;
16851 int ecode4 = 0 ;
16852 PyObject * obj0 = 0 ;
16853 PyObject * obj1 = 0 ;
16854 PyObject * obj2 = 0 ;
16855 PyObject * obj3 = 0 ;
16856 char * kwnames[] = {
16857 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16858 };
16859
16860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16862 if (!SWIG_IsOK(res1)) {
16863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16864 }
16865 arg1 = reinterpret_cast< wxImage * >(argp1);
16866 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16867 if (!SWIG_IsOK(ecode2)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16869 }
16870 arg2 = static_cast< byte >(val2);
16871 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16872 if (!SWIG_IsOK(ecode3)) {
16873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16874 }
16875 arg3 = static_cast< byte >(val3);
16876 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16877 if (!SWIG_IsOK(ecode4)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16879 }
16880 arg4 = static_cast< byte >(val4);
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj = 0;
16896 wxImage *arg1 = (wxImage *) 0 ;
16897 wxString *arg2 = 0 ;
16898 wxString *arg3 = 0 ;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 bool temp2 = false ;
16902 bool temp3 = false ;
16903 PyObject * obj0 = 0 ;
16904 PyObject * obj1 = 0 ;
16905 PyObject * obj2 = 0 ;
16906 char * kwnames[] = {
16907 (char *) "self",(char *) "name",(char *) "value", NULL
16908 };
16909
16910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16912 if (!SWIG_IsOK(res1)) {
16913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16914 }
16915 arg1 = reinterpret_cast< wxImage * >(argp1);
16916 {
16917 arg2 = wxString_in_helper(obj1);
16918 if (arg2 == NULL) SWIG_fail;
16919 temp2 = true;
16920 }
16921 {
16922 arg3 = wxString_in_helper(obj2);
16923 if (arg3 == NULL) SWIG_fail;
16924 temp3 = true;
16925 }
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 resultobj = SWIG_Py_Void();
16933 {
16934 if (temp2)
16935 delete arg2;
16936 }
16937 {
16938 if (temp3)
16939 delete arg3;
16940 }
16941 return resultobj;
16942 fail:
16943 {
16944 if (temp2)
16945 delete arg2;
16946 }
16947 {
16948 if (temp3)
16949 delete arg3;
16950 }
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16956 PyObject *resultobj = 0;
16957 wxImage *arg1 = (wxImage *) 0 ;
16958 wxString *arg2 = 0 ;
16959 int arg3 ;
16960 void *argp1 = 0 ;
16961 int res1 = 0 ;
16962 bool temp2 = false ;
16963 int val3 ;
16964 int ecode3 = 0 ;
16965 PyObject * obj0 = 0 ;
16966 PyObject * obj1 = 0 ;
16967 PyObject * obj2 = 0 ;
16968 char * kwnames[] = {
16969 (char *) "self",(char *) "name",(char *) "value", NULL
16970 };
16971
16972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16974 if (!SWIG_IsOK(res1)) {
16975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16976 }
16977 arg1 = reinterpret_cast< wxImage * >(argp1);
16978 {
16979 arg2 = wxString_in_helper(obj1);
16980 if (arg2 == NULL) SWIG_fail;
16981 temp2 = true;
16982 }
16983 ecode3 = SWIG_AsVal_int(obj2, &val3);
16984 if (!SWIG_IsOK(ecode3)) {
16985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16986 }
16987 arg3 = static_cast< int >(val3);
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 (arg1)->SetOption((wxString const &)*arg2,arg3);
16991 wxPyEndAllowThreads(__tstate);
16992 if (PyErr_Occurred()) SWIG_fail;
16993 }
16994 resultobj = SWIG_Py_Void();
16995 {
16996 if (temp2)
16997 delete arg2;
16998 }
16999 return resultobj;
17000 fail:
17001 {
17002 if (temp2)
17003 delete arg2;
17004 }
17005 return NULL;
17006 }
17007
17008
17009 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj = 0;
17011 wxImage *arg1 = (wxImage *) 0 ;
17012 wxString *arg2 = 0 ;
17013 wxString result;
17014 void *argp1 = 0 ;
17015 int res1 = 0 ;
17016 bool temp2 = false ;
17017 PyObject * obj0 = 0 ;
17018 PyObject * obj1 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "self",(char *) "name", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
17024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17025 if (!SWIG_IsOK(res1)) {
17026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17027 }
17028 arg1 = reinterpret_cast< wxImage * >(argp1);
17029 {
17030 arg2 = wxString_in_helper(obj1);
17031 if (arg2 == NULL) SWIG_fail;
17032 temp2 = true;
17033 }
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
17037 wxPyEndAllowThreads(__tstate);
17038 if (PyErr_Occurred()) SWIG_fail;
17039 }
17040 {
17041 #if wxUSE_UNICODE
17042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17043 #else
17044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17045 #endif
17046 }
17047 {
17048 if (temp2)
17049 delete arg2;
17050 }
17051 return resultobj;
17052 fail:
17053 {
17054 if (temp2)
17055 delete arg2;
17056 }
17057 return NULL;
17058 }
17059
17060
17061 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17062 PyObject *resultobj = 0;
17063 wxImage *arg1 = (wxImage *) 0 ;
17064 wxString *arg2 = 0 ;
17065 int result;
17066 void *argp1 = 0 ;
17067 int res1 = 0 ;
17068 bool temp2 = false ;
17069 PyObject * obj0 = 0 ;
17070 PyObject * obj1 = 0 ;
17071 char * kwnames[] = {
17072 (char *) "self",(char *) "name", NULL
17073 };
17074
17075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
17076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17077 if (!SWIG_IsOK(res1)) {
17078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
17079 }
17080 arg1 = reinterpret_cast< wxImage * >(argp1);
17081 {
17082 arg2 = wxString_in_helper(obj1);
17083 if (arg2 == NULL) SWIG_fail;
17084 temp2 = true;
17085 }
17086 {
17087 PyThreadState* __tstate = wxPyBeginAllowThreads();
17088 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
17089 wxPyEndAllowThreads(__tstate);
17090 if (PyErr_Occurred()) SWIG_fail;
17091 }
17092 resultobj = SWIG_From_int(static_cast< int >(result));
17093 {
17094 if (temp2)
17095 delete arg2;
17096 }
17097 return resultobj;
17098 fail:
17099 {
17100 if (temp2)
17101 delete arg2;
17102 }
17103 return NULL;
17104 }
17105
17106
17107 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17108 PyObject *resultobj = 0;
17109 wxImage *arg1 = (wxImage *) 0 ;
17110 wxString *arg2 = 0 ;
17111 bool result;
17112 void *argp1 = 0 ;
17113 int res1 = 0 ;
17114 bool temp2 = false ;
17115 PyObject * obj0 = 0 ;
17116 PyObject * obj1 = 0 ;
17117 char * kwnames[] = {
17118 (char *) "self",(char *) "name", NULL
17119 };
17120
17121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
17122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17123 if (!SWIG_IsOK(res1)) {
17124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
17125 }
17126 arg1 = reinterpret_cast< wxImage * >(argp1);
17127 {
17128 arg2 = wxString_in_helper(obj1);
17129 if (arg2 == NULL) SWIG_fail;
17130 temp2 = true;
17131 }
17132 {
17133 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
17135 wxPyEndAllowThreads(__tstate);
17136 if (PyErr_Occurred()) SWIG_fail;
17137 }
17138 {
17139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17140 }
17141 {
17142 if (temp2)
17143 delete arg2;
17144 }
17145 return resultobj;
17146 fail:
17147 {
17148 if (temp2)
17149 delete arg2;
17150 }
17151 return NULL;
17152 }
17153
17154
17155 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage *arg1 = (wxImage *) 0 ;
17158 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
17159 unsigned long result;
17160 void *argp1 = 0 ;
17161 int res1 = 0 ;
17162 unsigned long val2 ;
17163 int ecode2 = 0 ;
17164 PyObject * obj0 = 0 ;
17165 PyObject * obj1 = 0 ;
17166 char * kwnames[] = {
17167 (char *) "self",(char *) "stopafter", NULL
17168 };
17169
17170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
17171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17172 if (!SWIG_IsOK(res1)) {
17173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
17174 }
17175 arg1 = reinterpret_cast< wxImage * >(argp1);
17176 if (obj1) {
17177 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
17178 if (!SWIG_IsOK(ecode2)) {
17179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
17180 }
17181 arg2 = static_cast< unsigned long >(val2);
17182 }
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 result = (unsigned long)(arg1)->CountColours(arg2);
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj = 0;
17198 wxImage *arg1 = (wxImage *) 0 ;
17199 wxImageHistogram *arg2 = 0 ;
17200 unsigned long result;
17201 void *argp1 = 0 ;
17202 int res1 = 0 ;
17203 void *argp2 = 0 ;
17204 int res2 = 0 ;
17205 PyObject * obj0 = 0 ;
17206 PyObject * obj1 = 0 ;
17207 char * kwnames[] = {
17208 (char *) "self",(char *) "h", NULL
17209 };
17210
17211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
17212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17213 if (!SWIG_IsOK(res1)) {
17214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
17215 }
17216 arg1 = reinterpret_cast< wxImage * >(argp1);
17217 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
17218 if (!SWIG_IsOK(res2)) {
17219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17220 }
17221 if (!argp2) {
17222 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
17223 }
17224 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
17225 {
17226 PyThreadState* __tstate = wxPyBeginAllowThreads();
17227 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
17228 wxPyEndAllowThreads(__tstate);
17229 if (PyErr_Occurred()) SWIG_fail;
17230 }
17231 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj = 0;
17240 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17241 void *argp1 = 0 ;
17242 int res1 = 0 ;
17243 PyObject * obj0 = 0 ;
17244 char * kwnames[] = {
17245 (char *) "handler", NULL
17246 };
17247
17248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
17249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17250 if (!SWIG_IsOK(res1)) {
17251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17252 }
17253 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17254 {
17255 PyThreadState* __tstate = wxPyBeginAllowThreads();
17256 wxImage::AddHandler(arg1);
17257 wxPyEndAllowThreads(__tstate);
17258 if (PyErr_Occurred()) SWIG_fail;
17259 }
17260 resultobj = SWIG_Py_Void();
17261 return resultobj;
17262 fail:
17263 return NULL;
17264 }
17265
17266
17267 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17268 PyObject *resultobj = 0;
17269 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
17270 void *argp1 = 0 ;
17271 int res1 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 char * kwnames[] = {
17274 (char *) "handler", NULL
17275 };
17276
17277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
17278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
17279 if (!SWIG_IsOK(res1)) {
17280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
17281 }
17282 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
17283 {
17284 PyThreadState* __tstate = wxPyBeginAllowThreads();
17285 wxImage::InsertHandler(arg1);
17286 wxPyEndAllowThreads(__tstate);
17287 if (PyErr_Occurred()) SWIG_fail;
17288 }
17289 resultobj = SWIG_Py_Void();
17290 return resultobj;
17291 fail:
17292 return NULL;
17293 }
17294
17295
17296 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17297 PyObject *resultobj = 0;
17298 wxString *arg1 = 0 ;
17299 bool result;
17300 bool temp1 = false ;
17301 PyObject * obj0 = 0 ;
17302 char * kwnames[] = {
17303 (char *) "name", NULL
17304 };
17305
17306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
17307 {
17308 arg1 = wxString_in_helper(obj0);
17309 if (arg1 == NULL) SWIG_fail;
17310 temp1 = true;
17311 }
17312 {
17313 PyThreadState* __tstate = wxPyBeginAllowThreads();
17314 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
17315 wxPyEndAllowThreads(__tstate);
17316 if (PyErr_Occurred()) SWIG_fail;
17317 }
17318 {
17319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17320 }
17321 {
17322 if (temp1)
17323 delete arg1;
17324 }
17325 return resultobj;
17326 fail:
17327 {
17328 if (temp1)
17329 delete arg1;
17330 }
17331 return NULL;
17332 }
17333
17334
17335 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17336 PyObject *resultobj = 0;
17337 PyObject *result = 0 ;
17338
17339 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
17340 {
17341 PyThreadState* __tstate = wxPyBeginAllowThreads();
17342 result = (PyObject *)wxImage_GetHandlers();
17343 wxPyEndAllowThreads(__tstate);
17344 if (PyErr_Occurred()) SWIG_fail;
17345 }
17346 resultobj = result;
17347 return resultobj;
17348 fail:
17349 return NULL;
17350 }
17351
17352
17353 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17354 PyObject *resultobj = 0;
17355 wxString result;
17356
17357 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
17358 {
17359 PyThreadState* __tstate = wxPyBeginAllowThreads();
17360 result = wxImage::GetImageExtWildcard();
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 #if wxUSE_UNICODE
17366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17367 #else
17368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17369 #endif
17370 }
17371 return resultobj;
17372 fail:
17373 return NULL;
17374 }
17375
17376
17377 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17378 PyObject *resultobj = 0;
17379 wxImage *arg1 = (wxImage *) 0 ;
17380 int arg2 = (int) -1 ;
17381 wxBitmap result;
17382 void *argp1 = 0 ;
17383 int res1 = 0 ;
17384 int val2 ;
17385 int ecode2 = 0 ;
17386 PyObject * obj0 = 0 ;
17387 PyObject * obj1 = 0 ;
17388 char * kwnames[] = {
17389 (char *) "self",(char *) "depth", NULL
17390 };
17391
17392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17394 if (!SWIG_IsOK(res1)) {
17395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17396 }
17397 arg1 = reinterpret_cast< wxImage * >(argp1);
17398 if (obj1) {
17399 ecode2 = SWIG_AsVal_int(obj1, &val2);
17400 if (!SWIG_IsOK(ecode2)) {
17401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17402 }
17403 arg2 = static_cast< int >(val2);
17404 }
17405 {
17406 if (!wxPyCheckForApp()) SWIG_fail;
17407 PyThreadState* __tstate = wxPyBeginAllowThreads();
17408 result = wxImage_ConvertToBitmap(arg1,arg2);
17409 wxPyEndAllowThreads(__tstate);
17410 if (PyErr_Occurred()) SWIG_fail;
17411 }
17412 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17413 return resultobj;
17414 fail:
17415 return NULL;
17416 }
17417
17418
17419 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17420 PyObject *resultobj = 0;
17421 wxImage *arg1 = (wxImage *) 0 ;
17422 byte arg2 ;
17423 byte arg3 ;
17424 byte arg4 ;
17425 wxBitmap result;
17426 void *argp1 = 0 ;
17427 int res1 = 0 ;
17428 unsigned char val2 ;
17429 int ecode2 = 0 ;
17430 unsigned char val3 ;
17431 int ecode3 = 0 ;
17432 unsigned char val4 ;
17433 int ecode4 = 0 ;
17434 PyObject * obj0 = 0 ;
17435 PyObject * obj1 = 0 ;
17436 PyObject * obj2 = 0 ;
17437 PyObject * obj3 = 0 ;
17438 char * kwnames[] = {
17439 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17440 };
17441
17442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17444 if (!SWIG_IsOK(res1)) {
17445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17446 }
17447 arg1 = reinterpret_cast< wxImage * >(argp1);
17448 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17449 if (!SWIG_IsOK(ecode2)) {
17450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17451 }
17452 arg2 = static_cast< byte >(val2);
17453 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17454 if (!SWIG_IsOK(ecode3)) {
17455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17456 }
17457 arg3 = static_cast< byte >(val3);
17458 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17459 if (!SWIG_IsOK(ecode4)) {
17460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17461 }
17462 arg4 = static_cast< byte >(val4);
17463 {
17464 if (!wxPyCheckForApp()) SWIG_fail;
17465 PyThreadState* __tstate = wxPyBeginAllowThreads();
17466 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17471 return resultobj;
17472 fail:
17473 return NULL;
17474 }
17475
17476
17477 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17478 PyObject *resultobj = 0;
17479 wxImage *arg1 = (wxImage *) 0 ;
17480 double arg2 ;
17481 void *argp1 = 0 ;
17482 int res1 = 0 ;
17483 double val2 ;
17484 int ecode2 = 0 ;
17485 PyObject * obj0 = 0 ;
17486 PyObject * obj1 = 0 ;
17487 char * kwnames[] = {
17488 (char *) "self",(char *) "angle", NULL
17489 };
17490
17491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17493 if (!SWIG_IsOK(res1)) {
17494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17495 }
17496 arg1 = reinterpret_cast< wxImage * >(argp1);
17497 ecode2 = SWIG_AsVal_double(obj1, &val2);
17498 if (!SWIG_IsOK(ecode2)) {
17499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17500 }
17501 arg2 = static_cast< double >(val2);
17502 {
17503 PyThreadState* __tstate = wxPyBeginAllowThreads();
17504 (arg1)->RotateHue(arg2);
17505 wxPyEndAllowThreads(__tstate);
17506 if (PyErr_Occurred()) SWIG_fail;
17507 }
17508 resultobj = SWIG_Py_Void();
17509 return resultobj;
17510 fail:
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj = 0;
17517 wxImage_RGBValue arg1 ;
17518 wxImage_HSVValue result;
17519 void *argp1 ;
17520 int res1 = 0 ;
17521 PyObject * obj0 = 0 ;
17522 char * kwnames[] = {
17523 (char *) "rgb", NULL
17524 };
17525
17526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17527 {
17528 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17529 if (!SWIG_IsOK(res1)) {
17530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17531 }
17532 if (!argp1) {
17533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17534 } else {
17535 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17536 arg1 = *temp;
17537 if (SWIG_IsNewObj(res1)) delete temp;
17538 }
17539 }
17540 {
17541 PyThreadState* __tstate = wxPyBeginAllowThreads();
17542 result = wxImage::RGBtoHSV(arg1);
17543 wxPyEndAllowThreads(__tstate);
17544 if (PyErr_Occurred()) SWIG_fail;
17545 }
17546 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17554 PyObject *resultobj = 0;
17555 wxImage_HSVValue arg1 ;
17556 wxImage_RGBValue result;
17557 void *argp1 ;
17558 int res1 = 0 ;
17559 PyObject * obj0 = 0 ;
17560 char * kwnames[] = {
17561 (char *) "hsv", NULL
17562 };
17563
17564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17565 {
17566 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17567 if (!SWIG_IsOK(res1)) {
17568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17569 }
17570 if (!argp1) {
17571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17572 } else {
17573 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17574 arg1 = *temp;
17575 if (SWIG_IsNewObj(res1)) delete temp;
17576 }
17577 }
17578 {
17579 PyThreadState* __tstate = wxPyBeginAllowThreads();
17580 result = wxImage::HSVtoRGB(arg1);
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17585 return resultobj;
17586 fail:
17587 return NULL;
17588 }
17589
17590
17591 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17592 PyObject *obj;
17593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17594 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17595 return SWIG_Py_Void();
17596 }
17597
17598 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17599 return SWIG_Python_InitShadowInstance(args);
17600 }
17601
17602 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17603 PyObject *resultobj = 0;
17604 int arg1 ;
17605 int arg2 ;
17606 buffer arg3 ;
17607 int arg4 ;
17608 buffer arg5 = (buffer) NULL ;
17609 int arg6 = (int) 0 ;
17610 wxImage *result = 0 ;
17611 int val1 ;
17612 int ecode1 = 0 ;
17613 int val2 ;
17614 int ecode2 = 0 ;
17615 Py_ssize_t temp3 ;
17616 Py_ssize_t temp5 ;
17617 PyObject * obj0 = 0 ;
17618 PyObject * obj1 = 0 ;
17619 PyObject * obj2 = 0 ;
17620 PyObject * obj3 = 0 ;
17621 char * kwnames[] = {
17622 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17623 };
17624
17625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17626 ecode1 = SWIG_AsVal_int(obj0, &val1);
17627 if (!SWIG_IsOK(ecode1)) {
17628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17629 }
17630 arg1 = static_cast< int >(val1);
17631 ecode2 = SWIG_AsVal_int(obj1, &val2);
17632 if (!SWIG_IsOK(ecode2)) {
17633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17634 }
17635 arg2 = static_cast< int >(val2);
17636 {
17637 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17638 arg4 = (int)temp3;
17639 }
17640 if (obj3) {
17641 {
17642 if (obj3 != Py_None) {
17643 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17644 arg6 = (int)temp5;
17645 }
17646 }
17647 }
17648 {
17649 PyThreadState* __tstate = wxPyBeginAllowThreads();
17650 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17651 wxPyEndAllowThreads(__tstate);
17652 if (PyErr_Occurred()) SWIG_fail;
17653 }
17654 {
17655 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17656 }
17657 return resultobj;
17658 fail:
17659 return NULL;
17660 }
17661
17662
17663 SWIGINTERN int NullImage_set(PyObject *) {
17664 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17665 return 1;
17666 }
17667
17668
17669 SWIGINTERN PyObject *NullImage_get(void) {
17670 PyObject *pyobj = 0;
17671
17672 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17673 return pyobj;
17674 }
17675
17676
17677 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17678 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17679 return 1;
17680 }
17681
17682
17683 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17684 PyObject *pyobj = 0;
17685
17686 {
17687 #if wxUSE_UNICODE
17688 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17689 #else
17690 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17691 #endif
17692 }
17693 return pyobj;
17694 }
17695
17696
17697 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17698 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17699 return 1;
17700 }
17701
17702
17703 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17704 PyObject *pyobj = 0;
17705
17706 {
17707 #if wxUSE_UNICODE
17708 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17709 #else
17710 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17711 #endif
17712 }
17713 return pyobj;
17714 }
17715
17716
17717 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17718 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17719 return 1;
17720 }
17721
17722
17723 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17724 PyObject *pyobj = 0;
17725
17726 {
17727 #if wxUSE_UNICODE
17728 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17729 #else
17730 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17731 #endif
17732 }
17733 return pyobj;
17734 }
17735
17736
17737 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17738 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17739 return 1;
17740 }
17741
17742
17743 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17744 PyObject *pyobj = 0;
17745
17746 {
17747 #if wxUSE_UNICODE
17748 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17749 #else
17750 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17751 #endif
17752 }
17753 return pyobj;
17754 }
17755
17756
17757 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17758 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17759 return 1;
17760 }
17761
17762
17763 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17764 PyObject *pyobj = 0;
17765
17766 {
17767 #if wxUSE_UNICODE
17768 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17769 #else
17770 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17771 #endif
17772 }
17773 return pyobj;
17774 }
17775
17776
17777 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17778 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17779 return 1;
17780 }
17781
17782
17783 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17784 PyObject *pyobj = 0;
17785
17786 {
17787 #if wxUSE_UNICODE
17788 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17789 #else
17790 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17791 #endif
17792 }
17793 return pyobj;
17794 }
17795
17796
17797 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17798 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17799 return 1;
17800 }
17801
17802
17803 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17804 PyObject *pyobj = 0;
17805
17806 {
17807 #if wxUSE_UNICODE
17808 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17809 #else
17810 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17811 #endif
17812 }
17813 return pyobj;
17814 }
17815
17816
17817 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17818 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17819 return 1;
17820 }
17821
17822
17823 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17824 PyObject *pyobj = 0;
17825
17826 {
17827 #if wxUSE_UNICODE
17828 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17829 #else
17830 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17831 #endif
17832 }
17833 return pyobj;
17834 }
17835
17836
17837 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17838 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17839 return 1;
17840 }
17841
17842
17843 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17844 PyObject *pyobj = 0;
17845
17846 {
17847 #if wxUSE_UNICODE
17848 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17849 #else
17850 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17851 #endif
17852 }
17853 return pyobj;
17854 }
17855
17856
17857 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17858 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17859 return 1;
17860 }
17861
17862
17863 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17864 PyObject *pyobj = 0;
17865
17866 {
17867 #if wxUSE_UNICODE
17868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17869 #else
17870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17871 #endif
17872 }
17873 return pyobj;
17874 }
17875
17876
17877 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17878 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17879 return 1;
17880 }
17881
17882
17883 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17884 PyObject *pyobj = 0;
17885
17886 {
17887 #if wxUSE_UNICODE
17888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17889 #else
17890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17891 #endif
17892 }
17893 return pyobj;
17894 }
17895
17896
17897 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17898 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17899 return 1;
17900 }
17901
17902
17903 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17904 PyObject *pyobj = 0;
17905
17906 {
17907 #if wxUSE_UNICODE
17908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17909 #else
17910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17911 #endif
17912 }
17913 return pyobj;
17914 }
17915
17916
17917 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17918 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17919 return 1;
17920 }
17921
17922
17923 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17924 PyObject *pyobj = 0;
17925
17926 {
17927 #if wxUSE_UNICODE
17928 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17929 #else
17930 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17931 #endif
17932 }
17933 return pyobj;
17934 }
17935
17936
17937 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17938 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17939 return 1;
17940 }
17941
17942
17943 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17944 PyObject *pyobj = 0;
17945
17946 {
17947 #if wxUSE_UNICODE
17948 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17949 #else
17950 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17951 #endif
17952 }
17953 return pyobj;
17954 }
17955
17956
17957 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17958 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17959 return 1;
17960 }
17961
17962
17963 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17964 PyObject *pyobj = 0;
17965
17966 {
17967 #if wxUSE_UNICODE
17968 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17969 #else
17970 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17971 #endif
17972 }
17973 return pyobj;
17974 }
17975
17976
17977 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17978 PyObject *resultobj = 0;
17979 wxBMPHandler *result = 0 ;
17980
17981 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = (wxBMPHandler *)new wxBMPHandler();
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *obj;
17997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17998 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17999 return SWIG_Py_Void();
18000 }
18001
18002 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 return SWIG_Python_InitShadowInstance(args);
18004 }
18005
18006 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18007 PyObject *resultobj = 0;
18008 wxICOHandler *result = 0 ;
18009
18010 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
18011 {
18012 PyThreadState* __tstate = wxPyBeginAllowThreads();
18013 result = (wxICOHandler *)new wxICOHandler();
18014 wxPyEndAllowThreads(__tstate);
18015 if (PyErr_Occurred()) SWIG_fail;
18016 }
18017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
18018 return resultobj;
18019 fail:
18020 return NULL;
18021 }
18022
18023
18024 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18025 PyObject *obj;
18026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18027 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
18028 return SWIG_Py_Void();
18029 }
18030
18031 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18032 return SWIG_Python_InitShadowInstance(args);
18033 }
18034
18035 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18036 PyObject *resultobj = 0;
18037 wxCURHandler *result = 0 ;
18038
18039 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (wxCURHandler *)new wxCURHandler();
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18054 PyObject *obj;
18055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18056 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
18057 return SWIG_Py_Void();
18058 }
18059
18060 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 return SWIG_Python_InitShadowInstance(args);
18062 }
18063
18064 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18065 PyObject *resultobj = 0;
18066 wxANIHandler *result = 0 ;
18067
18068 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
18069 {
18070 PyThreadState* __tstate = wxPyBeginAllowThreads();
18071 result = (wxANIHandler *)new wxANIHandler();
18072 wxPyEndAllowThreads(__tstate);
18073 if (PyErr_Occurred()) SWIG_fail;
18074 }
18075 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
18076 return resultobj;
18077 fail:
18078 return NULL;
18079 }
18080
18081
18082 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 PyObject *obj;
18084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18085 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
18086 return SWIG_Py_Void();
18087 }
18088
18089 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18090 return SWIG_Python_InitShadowInstance(args);
18091 }
18092
18093 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18094 PyObject *resultobj = 0;
18095 wxPNGHandler *result = 0 ;
18096
18097 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
18098 {
18099 PyThreadState* __tstate = wxPyBeginAllowThreads();
18100 result = (wxPNGHandler *)new wxPNGHandler();
18101 wxPyEndAllowThreads(__tstate);
18102 if (PyErr_Occurred()) SWIG_fail;
18103 }
18104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18112 PyObject *obj;
18113 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18114 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
18115 return SWIG_Py_Void();
18116 }
18117
18118 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18119 return SWIG_Python_InitShadowInstance(args);
18120 }
18121
18122 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18123 PyObject *resultobj = 0;
18124 wxGIFHandler *result = 0 ;
18125
18126 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
18127 {
18128 PyThreadState* __tstate = wxPyBeginAllowThreads();
18129 result = (wxGIFHandler *)new wxGIFHandler();
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18141 PyObject *obj;
18142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18143 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
18144 return SWIG_Py_Void();
18145 }
18146
18147 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18148 return SWIG_Python_InitShadowInstance(args);
18149 }
18150
18151 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18152 PyObject *resultobj = 0;
18153 wxPCXHandler *result = 0 ;
18154
18155 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
18156 {
18157 PyThreadState* __tstate = wxPyBeginAllowThreads();
18158 result = (wxPCXHandler *)new wxPCXHandler();
18159 wxPyEndAllowThreads(__tstate);
18160 if (PyErr_Occurred()) SWIG_fail;
18161 }
18162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
18163 return resultobj;
18164 fail:
18165 return NULL;
18166 }
18167
18168
18169 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18170 PyObject *obj;
18171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18172 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
18173 return SWIG_Py_Void();
18174 }
18175
18176 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18177 return SWIG_Python_InitShadowInstance(args);
18178 }
18179
18180 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18181 PyObject *resultobj = 0;
18182 wxJPEGHandler *result = 0 ;
18183
18184 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (wxJPEGHandler *)new wxJPEGHandler();
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *obj;
18200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18201 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
18202 return SWIG_Py_Void();
18203 }
18204
18205 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18206 return SWIG_Python_InitShadowInstance(args);
18207 }
18208
18209 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18210 PyObject *resultobj = 0;
18211 wxPNMHandler *result = 0 ;
18212
18213 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
18214 {
18215 PyThreadState* __tstate = wxPyBeginAllowThreads();
18216 result = (wxPNMHandler *)new wxPNMHandler();
18217 wxPyEndAllowThreads(__tstate);
18218 if (PyErr_Occurred()) SWIG_fail;
18219 }
18220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
18221 return resultobj;
18222 fail:
18223 return NULL;
18224 }
18225
18226
18227 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18228 PyObject *obj;
18229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18230 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
18231 return SWIG_Py_Void();
18232 }
18233
18234 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18235 return SWIG_Python_InitShadowInstance(args);
18236 }
18237
18238 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18239 PyObject *resultobj = 0;
18240 wxXPMHandler *result = 0 ;
18241
18242 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 result = (wxXPMHandler *)new wxXPMHandler();
18246 wxPyEndAllowThreads(__tstate);
18247 if (PyErr_Occurred()) SWIG_fail;
18248 }
18249 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
18250 return resultobj;
18251 fail:
18252 return NULL;
18253 }
18254
18255
18256 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18257 PyObject *obj;
18258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18259 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
18260 return SWIG_Py_Void();
18261 }
18262
18263 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18264 return SWIG_Python_InitShadowInstance(args);
18265 }
18266
18267 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18268 PyObject *resultobj = 0;
18269 wxTIFFHandler *result = 0 ;
18270
18271 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (wxTIFFHandler *)new wxTIFFHandler();
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18286 PyObject *obj;
18287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18288 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
18289 return SWIG_Py_Void();
18290 }
18291
18292 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18293 return SWIG_Python_InitShadowInstance(args);
18294 }
18295
18296 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18297 PyObject *resultobj = 0;
18298 wxImage *arg1 = 0 ;
18299 wxImage *arg2 = 0 ;
18300 int arg3 = (int) 236 ;
18301 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
18302 bool result;
18303 void *argp1 = 0 ;
18304 int res1 = 0 ;
18305 void *argp2 = 0 ;
18306 int res2 = 0 ;
18307 int val3 ;
18308 int ecode3 = 0 ;
18309 int val4 ;
18310 int ecode4 = 0 ;
18311 PyObject * obj0 = 0 ;
18312 PyObject * obj1 = 0 ;
18313 PyObject * obj2 = 0 ;
18314 PyObject * obj3 = 0 ;
18315 char * kwnames[] = {
18316 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
18317 };
18318
18319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18320 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
18321 if (!SWIG_IsOK(res1)) {
18322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18323 }
18324 if (!argp1) {
18325 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
18326 }
18327 arg1 = reinterpret_cast< wxImage * >(argp1);
18328 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
18329 if (!SWIG_IsOK(res2)) {
18330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18331 }
18332 if (!argp2) {
18333 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
18334 }
18335 arg2 = reinterpret_cast< wxImage * >(argp2);
18336 if (obj2) {
18337 ecode3 = SWIG_AsVal_int(obj2, &val3);
18338 if (!SWIG_IsOK(ecode3)) {
18339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
18340 }
18341 arg3 = static_cast< int >(val3);
18342 }
18343 if (obj3) {
18344 ecode4 = SWIG_AsVal_int(obj3, &val4);
18345 if (!SWIG_IsOK(ecode4)) {
18346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
18347 }
18348 arg4 = static_cast< int >(val4);
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 {
18357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18358 }
18359 return resultobj;
18360 fail:
18361 return NULL;
18362 }
18363
18364
18365 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18366 PyObject *obj;
18367 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18368 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18369 return SWIG_Py_Void();
18370 }
18371
18372 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18373 PyObject *resultobj = 0;
18374 wxEvtHandler *result = 0 ;
18375
18376 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (wxEvtHandler *)new wxEvtHandler();
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18393 wxEvtHandler *result = 0 ;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18403 }
18404 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = wxPyMake_wxObject(result, 0);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18421 PyObject *resultobj = 0;
18422 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18423 wxEvtHandler *result = 0 ;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 PyObject *swig_obj[1] ;
18427
18428 if (!args) SWIG_fail;
18429 swig_obj[0] = args;
18430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 {
18442 resultobj = wxPyMake_wxObject(result, 0);
18443 }
18444 return resultobj;
18445 fail:
18446 return NULL;
18447 }
18448
18449
18450 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18451 PyObject *resultobj = 0;
18452 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18453 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18454 void *argp1 = 0 ;
18455 int res1 = 0 ;
18456 void *argp2 = 0 ;
18457 int res2 = 0 ;
18458 PyObject * obj0 = 0 ;
18459 PyObject * obj1 = 0 ;
18460 char * kwnames[] = {
18461 (char *) "self",(char *) "handler", NULL
18462 };
18463
18464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18468 }
18469 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18471 if (!SWIG_IsOK(res2)) {
18472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18473 }
18474 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18475 {
18476 PyThreadState* __tstate = wxPyBeginAllowThreads();
18477 (arg1)->SetNextHandler(arg2);
18478 wxPyEndAllowThreads(__tstate);
18479 if (PyErr_Occurred()) SWIG_fail;
18480 }
18481 resultobj = SWIG_Py_Void();
18482 return resultobj;
18483 fail:
18484 return NULL;
18485 }
18486
18487
18488 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj = 0;
18490 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18491 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18492 void *argp1 = 0 ;
18493 int res1 = 0 ;
18494 void *argp2 = 0 ;
18495 int res2 = 0 ;
18496 PyObject * obj0 = 0 ;
18497 PyObject * obj1 = 0 ;
18498 char * kwnames[] = {
18499 (char *) "self",(char *) "handler", NULL
18500 };
18501
18502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18504 if (!SWIG_IsOK(res1)) {
18505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18506 }
18507 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18508 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18509 if (!SWIG_IsOK(res2)) {
18510 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18511 }
18512 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18513 {
18514 PyThreadState* __tstate = wxPyBeginAllowThreads();
18515 (arg1)->SetPreviousHandler(arg2);
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 resultobj = SWIG_Py_Void();
18520 return resultobj;
18521 fail:
18522 return NULL;
18523 }
18524
18525
18526 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18527 PyObject *resultobj = 0;
18528 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18529 bool result;
18530 void *argp1 = 0 ;
18531 int res1 = 0 ;
18532 PyObject *swig_obj[1] ;
18533
18534 if (!args) SWIG_fail;
18535 swig_obj[0] = args;
18536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18537 if (!SWIG_IsOK(res1)) {
18538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18539 }
18540 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (bool)(arg1)->GetEvtHandlerEnabled();
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 {
18548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18549 }
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj = 0;
18558 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18559 bool arg2 ;
18560 void *argp1 = 0 ;
18561 int res1 = 0 ;
18562 bool val2 ;
18563 int ecode2 = 0 ;
18564 PyObject * obj0 = 0 ;
18565 PyObject * obj1 = 0 ;
18566 char * kwnames[] = {
18567 (char *) "self",(char *) "enabled", NULL
18568 };
18569
18570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18572 if (!SWIG_IsOK(res1)) {
18573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18574 }
18575 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18577 if (!SWIG_IsOK(ecode2)) {
18578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18579 }
18580 arg2 = static_cast< bool >(val2);
18581 {
18582 PyThreadState* __tstate = wxPyBeginAllowThreads();
18583 (arg1)->SetEvtHandlerEnabled(arg2);
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 resultobj = SWIG_Py_Void();
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18595 PyObject *resultobj = 0;
18596 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18597 wxEvent *arg2 = 0 ;
18598 bool result;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 void *argp2 = 0 ;
18602 int res2 = 0 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char * kwnames[] = {
18606 (char *) "self",(char *) "event", NULL
18607 };
18608
18609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18611 if (!SWIG_IsOK(res1)) {
18612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18613 }
18614 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18615 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18616 if (!SWIG_IsOK(res2)) {
18617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18618 }
18619 if (!argp2) {
18620 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18621 }
18622 arg2 = reinterpret_cast< wxEvent * >(argp2);
18623 {
18624 PyThreadState* __tstate = wxPyBeginAllowThreads();
18625 result = (bool)(arg1)->ProcessEvent(*arg2);
18626 wxPyEndAllowThreads(__tstate);
18627 if (PyErr_Occurred()) SWIG_fail;
18628 }
18629 {
18630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18631 }
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18639 PyObject *resultobj = 0;
18640 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18641 wxEvent *arg2 = 0 ;
18642 void *argp1 = 0 ;
18643 int res1 = 0 ;
18644 void *argp2 = 0 ;
18645 int res2 = 0 ;
18646 PyObject * obj0 = 0 ;
18647 PyObject * obj1 = 0 ;
18648 char * kwnames[] = {
18649 (char *) "self",(char *) "event", NULL
18650 };
18651
18652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18654 if (!SWIG_IsOK(res1)) {
18655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18656 }
18657 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18659 if (!SWIG_IsOK(res2)) {
18660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18661 }
18662 if (!argp2) {
18663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18664 }
18665 arg2 = reinterpret_cast< wxEvent * >(argp2);
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 (arg1)->AddPendingEvent(*arg2);
18669 wxPyEndAllowThreads(__tstate);
18670 if (PyErr_Occurred()) SWIG_fail;
18671 }
18672 resultobj = SWIG_Py_Void();
18673 return resultobj;
18674 fail:
18675 return NULL;
18676 }
18677
18678
18679 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18680 PyObject *resultobj = 0;
18681 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 PyObject *swig_obj[1] ;
18685
18686 if (!args) SWIG_fail;
18687 swig_obj[0] = args;
18688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18689 if (!SWIG_IsOK(res1)) {
18690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18691 }
18692 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 (arg1)->ProcessPendingEvents();
18696 wxPyEndAllowThreads(__tstate);
18697 if (PyErr_Occurred()) SWIG_fail;
18698 }
18699 resultobj = SWIG_Py_Void();
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj = 0;
18708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18709 bool arg2 = (bool) true ;
18710 void *argp1 = 0 ;
18711 int res1 = 0 ;
18712 bool val2 ;
18713 int ecode2 = 0 ;
18714 PyObject * obj0 = 0 ;
18715 PyObject * obj1 = 0 ;
18716 char * kwnames[] = {
18717 (char *) "self",(char *) "allow", NULL
18718 };
18719
18720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
18721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18722 if (!SWIG_IsOK(res1)) {
18723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18724 }
18725 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18726 if (obj1) {
18727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18728 if (!SWIG_IsOK(ecode2)) {
18729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
18730 }
18731 arg2 = static_cast< bool >(val2);
18732 }
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 (arg1)->AllowReentrance(arg2);
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 resultobj = SWIG_Py_Void();
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18747 PyObject *resultobj = 0;
18748 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18749 bool result;
18750 void *argp1 = 0 ;
18751 int res1 = 0 ;
18752 PyObject *swig_obj[1] ;
18753
18754 if (!args) SWIG_fail;
18755 swig_obj[0] = args;
18756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18757 if (!SWIG_IsOK(res1)) {
18758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18759 }
18760 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 result = (bool)(arg1)->IsReentranceAllowed();
18764 wxPyEndAllowThreads(__tstate);
18765 if (PyErr_Occurred()) SWIG_fail;
18766 }
18767 {
18768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18769 }
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 PyObject *resultobj = 0;
18778 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18779 bool result;
18780 void *argp1 = 0 ;
18781 int res1 = 0 ;
18782 PyObject *swig_obj[1] ;
18783
18784 if (!args) SWIG_fail;
18785 swig_obj[0] = args;
18786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18787 if (!SWIG_IsOK(res1)) {
18788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18789 }
18790 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 result = (bool)(arg1)->IsEventHandlingInProgress();
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 {
18798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18799 }
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj = 0;
18808 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18809 int arg2 ;
18810 int arg3 ;
18811 int arg4 ;
18812 PyObject *arg5 = (PyObject *) 0 ;
18813 void *argp1 = 0 ;
18814 int res1 = 0 ;
18815 int val2 ;
18816 int ecode2 = 0 ;
18817 int val3 ;
18818 int ecode3 = 0 ;
18819 int val4 ;
18820 int ecode4 = 0 ;
18821 PyObject * obj0 = 0 ;
18822 PyObject * obj1 = 0 ;
18823 PyObject * obj2 = 0 ;
18824 PyObject * obj3 = 0 ;
18825 PyObject * obj4 = 0 ;
18826 char * kwnames[] = {
18827 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18828 };
18829
18830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18832 if (!SWIG_IsOK(res1)) {
18833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18834 }
18835 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18836 ecode2 = SWIG_AsVal_int(obj1, &val2);
18837 if (!SWIG_IsOK(ecode2)) {
18838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18839 }
18840 arg2 = static_cast< int >(val2);
18841 ecode3 = SWIG_AsVal_int(obj2, &val3);
18842 if (!SWIG_IsOK(ecode3)) {
18843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18844 }
18845 arg3 = static_cast< int >(val3);
18846 ecode4 = SWIG_AsVal_int(obj3, &val4);
18847 if (!SWIG_IsOK(ecode4)) {
18848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18849 }
18850 arg4 = static_cast< int >(val4);
18851 arg5 = obj4;
18852 {
18853 PyThreadState* __tstate = wxPyBeginAllowThreads();
18854 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18855 wxPyEndAllowThreads(__tstate);
18856 if (PyErr_Occurred()) SWIG_fail;
18857 }
18858 resultobj = SWIG_Py_Void();
18859 return resultobj;
18860 fail:
18861 return NULL;
18862 }
18863
18864
18865 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18866 PyObject *resultobj = 0;
18867 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18868 int arg2 ;
18869 int arg3 = (int) -1 ;
18870 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18871 bool result;
18872 void *argp1 = 0 ;
18873 int res1 = 0 ;
18874 int val2 ;
18875 int ecode2 = 0 ;
18876 int val3 ;
18877 int ecode3 = 0 ;
18878 int val4 ;
18879 int ecode4 = 0 ;
18880 PyObject * obj0 = 0 ;
18881 PyObject * obj1 = 0 ;
18882 PyObject * obj2 = 0 ;
18883 PyObject * obj3 = 0 ;
18884 char * kwnames[] = {
18885 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18886 };
18887
18888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18890 if (!SWIG_IsOK(res1)) {
18891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18892 }
18893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18894 ecode2 = SWIG_AsVal_int(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18897 }
18898 arg2 = static_cast< int >(val2);
18899 if (obj2) {
18900 ecode3 = SWIG_AsVal_int(obj2, &val3);
18901 if (!SWIG_IsOK(ecode3)) {
18902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18903 }
18904 arg3 = static_cast< int >(val3);
18905 }
18906 if (obj3) {
18907 ecode4 = SWIG_AsVal_int(obj3, &val4);
18908 if (!SWIG_IsOK(ecode4)) {
18909 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18910 }
18911 arg4 = static_cast< wxEventType >(val4);
18912 }
18913 {
18914 PyThreadState* __tstate = wxPyBeginAllowThreads();
18915 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18916 wxPyEndAllowThreads(__tstate);
18917 if (PyErr_Occurred()) SWIG_fail;
18918 }
18919 {
18920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18921 }
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj = 0;
18930 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18931 PyObject *arg2 = (PyObject *) 0 ;
18932 bool arg3 = (bool) true ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 bool val3 ;
18936 int ecode3 = 0 ;
18937 PyObject * obj0 = 0 ;
18938 PyObject * obj1 = 0 ;
18939 PyObject * obj2 = 0 ;
18940 char * kwnames[] = {
18941 (char *) "self",(char *) "_self",(char *) "incref", NULL
18942 };
18943
18944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18946 if (!SWIG_IsOK(res1)) {
18947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18948 }
18949 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18950 arg2 = obj1;
18951 if (obj2) {
18952 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18953 if (!SWIG_IsOK(ecode3)) {
18954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18955 }
18956 arg3 = static_cast< bool >(val3);
18957 }
18958 {
18959 PyThreadState* __tstate = wxPyBeginAllowThreads();
18960 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 resultobj = SWIG_Py_Void();
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18972 PyObject *obj;
18973 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18974 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18975 return SWIG_Py_Void();
18976 }
18977
18978 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18979 return SWIG_Python_InitShadowInstance(args);
18980 }
18981
18982 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18983 PyObject *resultobj = 0;
18984 wxEventType result;
18985
18986 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18987 {
18988 PyThreadState* __tstate = wxPyBeginAllowThreads();
18989 result = (wxEventType)wxNewEventType();
18990 wxPyEndAllowThreads(__tstate);
18991 if (PyErr_Occurred()) SWIG_fail;
18992 }
18993 resultobj = SWIG_From_int(static_cast< int >(result));
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19001 PyObject *resultobj = 0;
19002 wxEvent *arg1 = (wxEvent *) 0 ;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 PyObject *swig_obj[1] ;
19006
19007 if (!args) SWIG_fail;
19008 swig_obj[0] = args;
19009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
19012 }
19013 arg1 = reinterpret_cast< wxEvent * >(argp1);
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 delete arg1;
19017
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 resultobj = SWIG_Py_Void();
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj = 0;
19030 wxEvent *arg1 = (wxEvent *) 0 ;
19031 wxEventType arg2 ;
19032 void *argp1 = 0 ;
19033 int res1 = 0 ;
19034 int val2 ;
19035 int ecode2 = 0 ;
19036 PyObject * obj0 = 0 ;
19037 PyObject * obj1 = 0 ;
19038 char * kwnames[] = {
19039 (char *) "self",(char *) "typ", NULL
19040 };
19041
19042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
19043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19044 if (!SWIG_IsOK(res1)) {
19045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
19046 }
19047 arg1 = reinterpret_cast< wxEvent * >(argp1);
19048 ecode2 = SWIG_AsVal_int(obj1, &val2);
19049 if (!SWIG_IsOK(ecode2)) {
19050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
19051 }
19052 arg2 = static_cast< wxEventType >(val2);
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 (arg1)->SetEventType(arg2);
19056 wxPyEndAllowThreads(__tstate);
19057 if (PyErr_Occurred()) SWIG_fail;
19058 }
19059 resultobj = SWIG_Py_Void();
19060 return resultobj;
19061 fail:
19062 return NULL;
19063 }
19064
19065
19066 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19067 PyObject *resultobj = 0;
19068 wxEvent *arg1 = (wxEvent *) 0 ;
19069 wxEventType result;
19070 void *argp1 = 0 ;
19071 int res1 = 0 ;
19072 PyObject *swig_obj[1] ;
19073
19074 if (!args) SWIG_fail;
19075 swig_obj[0] = args;
19076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19077 if (!SWIG_IsOK(res1)) {
19078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
19079 }
19080 arg1 = reinterpret_cast< wxEvent * >(argp1);
19081 {
19082 PyThreadState* __tstate = wxPyBeginAllowThreads();
19083 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
19084 wxPyEndAllowThreads(__tstate);
19085 if (PyErr_Occurred()) SWIG_fail;
19086 }
19087 resultobj = SWIG_From_int(static_cast< int >(result));
19088 return resultobj;
19089 fail:
19090 return NULL;
19091 }
19092
19093
19094 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19095 PyObject *resultobj = 0;
19096 wxEvent *arg1 = (wxEvent *) 0 ;
19097 wxObject *result = 0 ;
19098 void *argp1 = 0 ;
19099 int res1 = 0 ;
19100 PyObject *swig_obj[1] ;
19101
19102 if (!args) SWIG_fail;
19103 swig_obj[0] = args;
19104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19105 if (!SWIG_IsOK(res1)) {
19106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
19107 }
19108 arg1 = reinterpret_cast< wxEvent * >(argp1);
19109 {
19110 PyThreadState* __tstate = wxPyBeginAllowThreads();
19111 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
19112 wxPyEndAllowThreads(__tstate);
19113 if (PyErr_Occurred()) SWIG_fail;
19114 }
19115 {
19116 resultobj = wxPyMake_wxObject(result, (bool)0);
19117 }
19118 return resultobj;
19119 fail:
19120 return NULL;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19125 PyObject *resultobj = 0;
19126 wxEvent *arg1 = (wxEvent *) 0 ;
19127 wxObject *arg2 = (wxObject *) 0 ;
19128 void *argp1 = 0 ;
19129 int res1 = 0 ;
19130 void *argp2 = 0 ;
19131 int res2 = 0 ;
19132 PyObject * obj0 = 0 ;
19133 PyObject * obj1 = 0 ;
19134 char * kwnames[] = {
19135 (char *) "self",(char *) "obj", NULL
19136 };
19137
19138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
19139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19140 if (!SWIG_IsOK(res1)) {
19141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
19142 }
19143 arg1 = reinterpret_cast< wxEvent * >(argp1);
19144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
19145 if (!SWIG_IsOK(res2)) {
19146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
19147 }
19148 arg2 = reinterpret_cast< wxObject * >(argp2);
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 (arg1)->SetEventObject(arg2);
19152 wxPyEndAllowThreads(__tstate);
19153 if (PyErr_Occurred()) SWIG_fail;
19154 }
19155 resultobj = SWIG_Py_Void();
19156 return resultobj;
19157 fail:
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19163 PyObject *resultobj = 0;
19164 wxEvent *arg1 = (wxEvent *) 0 ;
19165 long result;
19166 void *argp1 = 0 ;
19167 int res1 = 0 ;
19168 PyObject *swig_obj[1] ;
19169
19170 if (!args) SWIG_fail;
19171 swig_obj[0] = args;
19172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19173 if (!SWIG_IsOK(res1)) {
19174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
19175 }
19176 arg1 = reinterpret_cast< wxEvent * >(argp1);
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (long)((wxEvent const *)arg1)->GetTimestamp();
19180 wxPyEndAllowThreads(__tstate);
19181 if (PyErr_Occurred()) SWIG_fail;
19182 }
19183 resultobj = SWIG_From_long(static_cast< long >(result));
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj = 0;
19192 wxEvent *arg1 = (wxEvent *) 0 ;
19193 long arg2 = (long) 0 ;
19194 void *argp1 = 0 ;
19195 int res1 = 0 ;
19196 long val2 ;
19197 int ecode2 = 0 ;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 char * kwnames[] = {
19201 (char *) "self",(char *) "ts", NULL
19202 };
19203
19204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
19205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19206 if (!SWIG_IsOK(res1)) {
19207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
19208 }
19209 arg1 = reinterpret_cast< wxEvent * >(argp1);
19210 if (obj1) {
19211 ecode2 = SWIG_AsVal_long(obj1, &val2);
19212 if (!SWIG_IsOK(ecode2)) {
19213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
19214 }
19215 arg2 = static_cast< long >(val2);
19216 }
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 (arg1)->SetTimestamp(arg2);
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_Py_Void();
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 PyObject *resultobj = 0;
19232 wxEvent *arg1 = (wxEvent *) 0 ;
19233 int result;
19234 void *argp1 = 0 ;
19235 int res1 = 0 ;
19236 PyObject *swig_obj[1] ;
19237
19238 if (!args) SWIG_fail;
19239 swig_obj[0] = args;
19240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19241 if (!SWIG_IsOK(res1)) {
19242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
19243 }
19244 arg1 = reinterpret_cast< wxEvent * >(argp1);
19245 {
19246 PyThreadState* __tstate = wxPyBeginAllowThreads();
19247 result = (int)((wxEvent const *)arg1)->GetId();
19248 wxPyEndAllowThreads(__tstate);
19249 if (PyErr_Occurred()) SWIG_fail;
19250 }
19251 resultobj = SWIG_From_int(static_cast< int >(result));
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj = 0;
19260 wxEvent *arg1 = (wxEvent *) 0 ;
19261 int arg2 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 int val2 ;
19265 int ecode2 = 0 ;
19266 PyObject * obj0 = 0 ;
19267 PyObject * obj1 = 0 ;
19268 char * kwnames[] = {
19269 (char *) "self",(char *) "Id", NULL
19270 };
19271
19272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
19273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19274 if (!SWIG_IsOK(res1)) {
19275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
19276 }
19277 arg1 = reinterpret_cast< wxEvent * >(argp1);
19278 ecode2 = SWIG_AsVal_int(obj1, &val2);
19279 if (!SWIG_IsOK(ecode2)) {
19280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
19281 }
19282 arg2 = static_cast< int >(val2);
19283 {
19284 PyThreadState* __tstate = wxPyBeginAllowThreads();
19285 (arg1)->SetId(arg2);
19286 wxPyEndAllowThreads(__tstate);
19287 if (PyErr_Occurred()) SWIG_fail;
19288 }
19289 resultobj = SWIG_Py_Void();
19290 return resultobj;
19291 fail:
19292 return NULL;
19293 }
19294
19295
19296 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19297 PyObject *resultobj = 0;
19298 wxEvent *arg1 = (wxEvent *) 0 ;
19299 bool result;
19300 void *argp1 = 0 ;
19301 int res1 = 0 ;
19302 PyObject *swig_obj[1] ;
19303
19304 if (!args) SWIG_fail;
19305 swig_obj[0] = args;
19306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19307 if (!SWIG_IsOK(res1)) {
19308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
19309 }
19310 arg1 = reinterpret_cast< wxEvent * >(argp1);
19311 {
19312 PyThreadState* __tstate = wxPyBeginAllowThreads();
19313 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19319 }
19320 return resultobj;
19321 fail:
19322 return NULL;
19323 }
19324
19325
19326 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19327 PyObject *resultobj = 0;
19328 wxEvent *arg1 = (wxEvent *) 0 ;
19329 bool arg2 = (bool) true ;
19330 void *argp1 = 0 ;
19331 int res1 = 0 ;
19332 bool val2 ;
19333 int ecode2 = 0 ;
19334 PyObject * obj0 = 0 ;
19335 PyObject * obj1 = 0 ;
19336 char * kwnames[] = {
19337 (char *) "self",(char *) "skip", NULL
19338 };
19339
19340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
19341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19342 if (!SWIG_IsOK(res1)) {
19343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
19344 }
19345 arg1 = reinterpret_cast< wxEvent * >(argp1);
19346 if (obj1) {
19347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19348 if (!SWIG_IsOK(ecode2)) {
19349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
19350 }
19351 arg2 = static_cast< bool >(val2);
19352 }
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 (arg1)->Skip(arg2);
19356 wxPyEndAllowThreads(__tstate);
19357 if (PyErr_Occurred()) SWIG_fail;
19358 }
19359 resultobj = SWIG_Py_Void();
19360 return resultobj;
19361 fail:
19362 return NULL;
19363 }
19364
19365
19366 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19367 PyObject *resultobj = 0;
19368 wxEvent *arg1 = (wxEvent *) 0 ;
19369 bool result;
19370 void *argp1 = 0 ;
19371 int res1 = 0 ;
19372 PyObject *swig_obj[1] ;
19373
19374 if (!args) SWIG_fail;
19375 swig_obj[0] = args;
19376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19377 if (!SWIG_IsOK(res1)) {
19378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
19379 }
19380 arg1 = reinterpret_cast< wxEvent * >(argp1);
19381 {
19382 PyThreadState* __tstate = wxPyBeginAllowThreads();
19383 result = (bool)((wxEvent const *)arg1)->GetSkipped();
19384 wxPyEndAllowThreads(__tstate);
19385 if (PyErr_Occurred()) SWIG_fail;
19386 }
19387 {
19388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19389 }
19390 return resultobj;
19391 fail:
19392 return NULL;
19393 }
19394
19395
19396 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19397 PyObject *resultobj = 0;
19398 wxEvent *arg1 = (wxEvent *) 0 ;
19399 bool result;
19400 void *argp1 = 0 ;
19401 int res1 = 0 ;
19402 PyObject *swig_obj[1] ;
19403
19404 if (!args) SWIG_fail;
19405 swig_obj[0] = args;
19406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19407 if (!SWIG_IsOK(res1)) {
19408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
19409 }
19410 arg1 = reinterpret_cast< wxEvent * >(argp1);
19411 {
19412 PyThreadState* __tstate = wxPyBeginAllowThreads();
19413 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
19414 wxPyEndAllowThreads(__tstate);
19415 if (PyErr_Occurred()) SWIG_fail;
19416 }
19417 {
19418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19419 }
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19427 PyObject *resultobj = 0;
19428 wxEvent *arg1 = (wxEvent *) 0 ;
19429 int result;
19430 void *argp1 = 0 ;
19431 int res1 = 0 ;
19432 PyObject *swig_obj[1] ;
19433
19434 if (!args) SWIG_fail;
19435 swig_obj[0] = args;
19436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxEvent * >(argp1);
19441 {
19442 PyThreadState* __tstate = wxPyBeginAllowThreads();
19443 result = (int)(arg1)->StopPropagation();
19444 wxPyEndAllowThreads(__tstate);
19445 if (PyErr_Occurred()) SWIG_fail;
19446 }
19447 resultobj = SWIG_From_int(static_cast< int >(result));
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19455 PyObject *resultobj = 0;
19456 wxEvent *arg1 = (wxEvent *) 0 ;
19457 int arg2 ;
19458 void *argp1 = 0 ;
19459 int res1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 PyObject * obj0 = 0 ;
19463 PyObject * obj1 = 0 ;
19464 char * kwnames[] = {
19465 (char *) "self",(char *) "propagationLevel", NULL
19466 };
19467
19468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19472 }
19473 arg1 = reinterpret_cast< wxEvent * >(argp1);
19474 ecode2 = SWIG_AsVal_int(obj1, &val2);
19475 if (!SWIG_IsOK(ecode2)) {
19476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19477 }
19478 arg2 = static_cast< int >(val2);
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 (arg1)->ResumePropagation(arg2);
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_Py_Void();
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 PyObject *resultobj = 0;
19494 wxEvent *arg1 = (wxEvent *) 0 ;
19495 wxEvent *result = 0 ;
19496 void *argp1 = 0 ;
19497 int res1 = 0 ;
19498 PyObject *swig_obj[1] ;
19499
19500 if (!args) SWIG_fail;
19501 swig_obj[0] = args;
19502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19503 if (!SWIG_IsOK(res1)) {
19504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19505 }
19506 arg1 = reinterpret_cast< wxEvent * >(argp1);
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 result = (wxEvent *)(arg1)->Clone();
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19514 return resultobj;
19515 fail:
19516 return NULL;
19517 }
19518
19519
19520 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19521 PyObject *obj;
19522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19523 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19524 return SWIG_Py_Void();
19525 }
19526
19527 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19528 PyObject *resultobj = 0;
19529 wxEvent *arg1 = 0 ;
19530 wxPropagationDisabler *result = 0 ;
19531 void *argp1 = 0 ;
19532 int res1 = 0 ;
19533 PyObject * obj0 = 0 ;
19534 char * kwnames[] = {
19535 (char *) "event", NULL
19536 };
19537
19538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19539 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19540 if (!SWIG_IsOK(res1)) {
19541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19542 }
19543 if (!argp1) {
19544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19545 }
19546 arg1 = reinterpret_cast< wxEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19563 void *argp1 = 0 ;
19564 int res1 = 0 ;
19565 PyObject *swig_obj[1] ;
19566
19567 if (!args) SWIG_fail;
19568 swig_obj[0] = args;
19569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19572 }
19573 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 delete arg1;
19577
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_Py_Void();
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19589 PyObject *obj;
19590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19591 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19592 return SWIG_Py_Void();
19593 }
19594
19595 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19596 return SWIG_Python_InitShadowInstance(args);
19597 }
19598
19599 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj = 0;
19601 wxEvent *arg1 = 0 ;
19602 wxPropagateOnce *result = 0 ;
19603 void *argp1 = 0 ;
19604 int res1 = 0 ;
19605 PyObject * obj0 = 0 ;
19606 char * kwnames[] = {
19607 (char *) "event", NULL
19608 };
19609
19610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19611 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19612 if (!SWIG_IsOK(res1)) {
19613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19614 }
19615 if (!argp1) {
19616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19617 }
19618 arg1 = reinterpret_cast< wxEvent * >(argp1);
19619 {
19620 PyThreadState* __tstate = wxPyBeginAllowThreads();
19621 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19622 wxPyEndAllowThreads(__tstate);
19623 if (PyErr_Occurred()) SWIG_fail;
19624 }
19625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19626 return resultobj;
19627 fail:
19628 return NULL;
19629 }
19630
19631
19632 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19633 PyObject *resultobj = 0;
19634 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19635 void *argp1 = 0 ;
19636 int res1 = 0 ;
19637 PyObject *swig_obj[1] ;
19638
19639 if (!args) SWIG_fail;
19640 swig_obj[0] = args;
19641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19644 }
19645 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19646 {
19647 PyThreadState* __tstate = wxPyBeginAllowThreads();
19648 delete arg1;
19649
19650 wxPyEndAllowThreads(__tstate);
19651 if (PyErr_Occurred()) SWIG_fail;
19652 }
19653 resultobj = SWIG_Py_Void();
19654 return resultobj;
19655 fail:
19656 return NULL;
19657 }
19658
19659
19660 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 PyObject *obj;
19662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19663 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19664 return SWIG_Py_Void();
19665 }
19666
19667 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19668 return SWIG_Python_InitShadowInstance(args);
19669 }
19670
19671 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19672 PyObject *resultobj = 0;
19673 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19674 int arg2 = (int) 0 ;
19675 wxCommandEvent *result = 0 ;
19676 int val1 ;
19677 int ecode1 = 0 ;
19678 int val2 ;
19679 int ecode2 = 0 ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "commandType",(char *) "winid", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 if (obj1) {
19695 ecode2 = SWIG_AsVal_int(obj1, &val2);
19696 if (!SWIG_IsOK(ecode2)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19698 }
19699 arg2 = static_cast< int >(val2);
19700 }
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19704 wxPyEndAllowThreads(__tstate);
19705 if (PyErr_Occurred()) SWIG_fail;
19706 }
19707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19708 return resultobj;
19709 fail:
19710 return NULL;
19711 }
19712
19713
19714 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19715 PyObject *resultobj = 0;
19716 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19717 int result;
19718 void *argp1 = 0 ;
19719 int res1 = 0 ;
19720 PyObject *swig_obj[1] ;
19721
19722 if (!args) SWIG_fail;
19723 swig_obj[0] = args;
19724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19725 if (!SWIG_IsOK(res1)) {
19726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19727 }
19728 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19729 {
19730 PyThreadState* __tstate = wxPyBeginAllowThreads();
19731 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19732 wxPyEndAllowThreads(__tstate);
19733 if (PyErr_Occurred()) SWIG_fail;
19734 }
19735 resultobj = SWIG_From_int(static_cast< int >(result));
19736 return resultobj;
19737 fail:
19738 return NULL;
19739 }
19740
19741
19742 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19743 PyObject *resultobj = 0;
19744 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19745 wxString *arg2 = 0 ;
19746 void *argp1 = 0 ;
19747 int res1 = 0 ;
19748 bool temp2 = false ;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 char * kwnames[] = {
19752 (char *) "self",(char *) "s", NULL
19753 };
19754
19755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19757 if (!SWIG_IsOK(res1)) {
19758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19759 }
19760 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19761 {
19762 arg2 = wxString_in_helper(obj1);
19763 if (arg2 == NULL) SWIG_fail;
19764 temp2 = true;
19765 }
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 (arg1)->SetString((wxString const &)*arg2);
19769 wxPyEndAllowThreads(__tstate);
19770 if (PyErr_Occurred()) SWIG_fail;
19771 }
19772 resultobj = SWIG_Py_Void();
19773 {
19774 if (temp2)
19775 delete arg2;
19776 }
19777 return resultobj;
19778 fail:
19779 {
19780 if (temp2)
19781 delete arg2;
19782 }
19783 return NULL;
19784 }
19785
19786
19787 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788 PyObject *resultobj = 0;
19789 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19790 wxString result;
19791 void *argp1 = 0 ;
19792 int res1 = 0 ;
19793 PyObject *swig_obj[1] ;
19794
19795 if (!args) SWIG_fail;
19796 swig_obj[0] = args;
19797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19798 if (!SWIG_IsOK(res1)) {
19799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19800 }
19801 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 result = ((wxCommandEvent const *)arg1)->GetString();
19805 wxPyEndAllowThreads(__tstate);
19806 if (PyErr_Occurred()) SWIG_fail;
19807 }
19808 {
19809 #if wxUSE_UNICODE
19810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19811 #else
19812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19813 #endif
19814 }
19815 return resultobj;
19816 fail:
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19822 PyObject *resultobj = 0;
19823 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19824 bool result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 PyObject *swig_obj[1] ;
19828
19829 if (!args) SWIG_fail;
19830 swig_obj[0] = args;
19831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19832 if (!SWIG_IsOK(res1)) {
19833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19834 }
19835 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19836 {
19837 PyThreadState* __tstate = wxPyBeginAllowThreads();
19838 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 {
19843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19844 }
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19852 PyObject *resultobj = 0;
19853 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19854 bool result;
19855 void *argp1 = 0 ;
19856 int res1 = 0 ;
19857 PyObject *swig_obj[1] ;
19858
19859 if (!args) SWIG_fail;
19860 swig_obj[0] = args;
19861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19862 if (!SWIG_IsOK(res1)) {
19863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19864 }
19865 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19866 {
19867 PyThreadState* __tstate = wxPyBeginAllowThreads();
19868 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 {
19873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj = 0;
19883 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19884 long arg2 ;
19885 void *argp1 = 0 ;
19886 int res1 = 0 ;
19887 long val2 ;
19888 int ecode2 = 0 ;
19889 PyObject * obj0 = 0 ;
19890 PyObject * obj1 = 0 ;
19891 char * kwnames[] = {
19892 (char *) "self",(char *) "extraLong", NULL
19893 };
19894
19895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19897 if (!SWIG_IsOK(res1)) {
19898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19899 }
19900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19901 ecode2 = SWIG_AsVal_long(obj1, &val2);
19902 if (!SWIG_IsOK(ecode2)) {
19903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19904 }
19905 arg2 = static_cast< long >(val2);
19906 {
19907 PyThreadState* __tstate = wxPyBeginAllowThreads();
19908 (arg1)->SetExtraLong(arg2);
19909 wxPyEndAllowThreads(__tstate);
19910 if (PyErr_Occurred()) SWIG_fail;
19911 }
19912 resultobj = SWIG_Py_Void();
19913 return resultobj;
19914 fail:
19915 return NULL;
19916 }
19917
19918
19919 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19920 PyObject *resultobj = 0;
19921 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19922 long result;
19923 void *argp1 = 0 ;
19924 int res1 = 0 ;
19925 PyObject *swig_obj[1] ;
19926
19927 if (!args) SWIG_fail;
19928 swig_obj[0] = args;
19929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19930 if (!SWIG_IsOK(res1)) {
19931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19932 }
19933 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19934 {
19935 PyThreadState* __tstate = wxPyBeginAllowThreads();
19936 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19937 wxPyEndAllowThreads(__tstate);
19938 if (PyErr_Occurred()) SWIG_fail;
19939 }
19940 resultobj = SWIG_From_long(static_cast< long >(result));
19941 return resultobj;
19942 fail:
19943 return NULL;
19944 }
19945
19946
19947 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj = 0;
19949 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19950 int arg2 ;
19951 void *argp1 = 0 ;
19952 int res1 = 0 ;
19953 int val2 ;
19954 int ecode2 = 0 ;
19955 PyObject * obj0 = 0 ;
19956 PyObject * obj1 = 0 ;
19957 char * kwnames[] = {
19958 (char *) "self",(char *) "i", NULL
19959 };
19960
19961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19965 }
19966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19967 ecode2 = SWIG_AsVal_int(obj1, &val2);
19968 if (!SWIG_IsOK(ecode2)) {
19969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19970 }
19971 arg2 = static_cast< int >(val2);
19972 {
19973 PyThreadState* __tstate = wxPyBeginAllowThreads();
19974 (arg1)->SetInt(arg2);
19975 wxPyEndAllowThreads(__tstate);
19976 if (PyErr_Occurred()) SWIG_fail;
19977 }
19978 resultobj = SWIG_Py_Void();
19979 return resultobj;
19980 fail:
19981 return NULL;
19982 }
19983
19984
19985 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19986 PyObject *resultobj = 0;
19987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19988 int result;
19989 void *argp1 = 0 ;
19990 int res1 = 0 ;
19991 PyObject *swig_obj[1] ;
19992
19993 if (!args) SWIG_fail;
19994 swig_obj[0] = args;
19995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19996 if (!SWIG_IsOK(res1)) {
19997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19998 }
19999 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20000 {
20001 PyThreadState* __tstate = wxPyBeginAllowThreads();
20002 result = (int)((wxCommandEvent const *)arg1)->GetInt();
20003 wxPyEndAllowThreads(__tstate);
20004 if (PyErr_Occurred()) SWIG_fail;
20005 }
20006 resultobj = SWIG_From_int(static_cast< int >(result));
20007 return resultobj;
20008 fail:
20009 return NULL;
20010 }
20011
20012
20013 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20014 PyObject *resultobj = 0;
20015 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20016 PyObject *result = 0 ;
20017 void *argp1 = 0 ;
20018 int res1 = 0 ;
20019 PyObject *swig_obj[1] ;
20020
20021 if (!args) SWIG_fail;
20022 swig_obj[0] = args;
20023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20024 if (!SWIG_IsOK(res1)) {
20025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20026 }
20027 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
20031 wxPyEndAllowThreads(__tstate);
20032 if (PyErr_Occurred()) SWIG_fail;
20033 }
20034 resultobj = result;
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20042 PyObject *resultobj = 0;
20043 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20044 PyObject *arg2 = (PyObject *) 0 ;
20045 void *argp1 = 0 ;
20046 int res1 = 0 ;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char * kwnames[] = {
20050 (char *) "self",(char *) "clientData", NULL
20051 };
20052
20053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
20054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20055 if (!SWIG_IsOK(res1)) {
20056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
20057 }
20058 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20059 arg2 = obj1;
20060 {
20061 PyThreadState* __tstate = wxPyBeginAllowThreads();
20062 wxCommandEvent_SetClientData(arg1,arg2);
20063 wxPyEndAllowThreads(__tstate);
20064 if (PyErr_Occurred()) SWIG_fail;
20065 }
20066 resultobj = SWIG_Py_Void();
20067 return resultobj;
20068 fail:
20069 return NULL;
20070 }
20071
20072
20073 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20074 PyObject *resultobj = 0;
20075 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
20076 wxEvent *result = 0 ;
20077 void *argp1 = 0 ;
20078 int res1 = 0 ;
20079 PyObject *swig_obj[1] ;
20080
20081 if (!args) SWIG_fail;
20082 swig_obj[0] = args;
20083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
20084 if (!SWIG_IsOK(res1)) {
20085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
20086 }
20087 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
20095 return resultobj;
20096 fail:
20097 return NULL;
20098 }
20099
20100
20101 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20102 PyObject *obj;
20103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20104 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
20105 return SWIG_Py_Void();
20106 }
20107
20108 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20109 return SWIG_Python_InitShadowInstance(args);
20110 }
20111
20112 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20113 PyObject *resultobj = 0;
20114 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20115 int arg2 = (int) 0 ;
20116 wxNotifyEvent *result = 0 ;
20117 int val1 ;
20118 int ecode1 = 0 ;
20119 int val2 ;
20120 int ecode2 = 0 ;
20121 PyObject * obj0 = 0 ;
20122 PyObject * obj1 = 0 ;
20123 char * kwnames[] = {
20124 (char *) "commandType",(char *) "winid", NULL
20125 };
20126
20127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20128 if (obj0) {
20129 ecode1 = SWIG_AsVal_int(obj0, &val1);
20130 if (!SWIG_IsOK(ecode1)) {
20131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20132 }
20133 arg1 = static_cast< wxEventType >(val1);
20134 }
20135 if (obj1) {
20136 ecode2 = SWIG_AsVal_int(obj1, &val2);
20137 if (!SWIG_IsOK(ecode2)) {
20138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
20139 }
20140 arg2 = static_cast< int >(val2);
20141 }
20142 {
20143 PyThreadState* __tstate = wxPyBeginAllowThreads();
20144 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
20145 wxPyEndAllowThreads(__tstate);
20146 if (PyErr_Occurred()) SWIG_fail;
20147 }
20148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
20149 return resultobj;
20150 fail:
20151 return NULL;
20152 }
20153
20154
20155 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20156 PyObject *resultobj = 0;
20157 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20158 void *argp1 = 0 ;
20159 int res1 = 0 ;
20160 PyObject *swig_obj[1] ;
20161
20162 if (!args) SWIG_fail;
20163 swig_obj[0] = args;
20164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20165 if (!SWIG_IsOK(res1)) {
20166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20167 }
20168 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20169 {
20170 PyThreadState* __tstate = wxPyBeginAllowThreads();
20171 (arg1)->Veto();
20172 wxPyEndAllowThreads(__tstate);
20173 if (PyErr_Occurred()) SWIG_fail;
20174 }
20175 resultobj = SWIG_Py_Void();
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 PyObject *swig_obj[1] ;
20188
20189 if (!args) SWIG_fail;
20190 swig_obj[0] = args;
20191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20192 if (!SWIG_IsOK(res1)) {
20193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20194 }
20195 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 (arg1)->Allow();
20199 wxPyEndAllowThreads(__tstate);
20200 if (PyErr_Occurred()) SWIG_fail;
20201 }
20202 resultobj = SWIG_Py_Void();
20203 return resultobj;
20204 fail:
20205 return NULL;
20206 }
20207
20208
20209 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 PyObject *resultobj = 0;
20211 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
20212 bool result;
20213 void *argp1 = 0 ;
20214 int res1 = 0 ;
20215 PyObject *swig_obj[1] ;
20216
20217 if (!args) SWIG_fail;
20218 swig_obj[0] = args;
20219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
20220 if (!SWIG_IsOK(res1)) {
20221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
20222 }
20223 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
20224 {
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = (bool)(arg1)->IsAllowed();
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 {
20231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20232 }
20233 return resultobj;
20234 fail:
20235 return NULL;
20236 }
20237
20238
20239 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20240 PyObject *obj;
20241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20242 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
20243 return SWIG_Py_Void();
20244 }
20245
20246 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 return SWIG_Python_InitShadowInstance(args);
20248 }
20249
20250 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20251 PyObject *resultobj = 0;
20252 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20253 int arg2 = (int) 0 ;
20254 int arg3 = (int) 0 ;
20255 int arg4 = (int) 0 ;
20256 wxScrollEvent *result = 0 ;
20257 int val1 ;
20258 int ecode1 = 0 ;
20259 int val2 ;
20260 int ecode2 = 0 ;
20261 int val3 ;
20262 int ecode3 = 0 ;
20263 int val4 ;
20264 int ecode4 = 0 ;
20265 PyObject * obj0 = 0 ;
20266 PyObject * obj1 = 0 ;
20267 PyObject * obj2 = 0 ;
20268 PyObject * obj3 = 0 ;
20269 char * kwnames[] = {
20270 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
20271 };
20272
20273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20274 if (obj0) {
20275 ecode1 = SWIG_AsVal_int(obj0, &val1);
20276 if (!SWIG_IsOK(ecode1)) {
20277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20278 }
20279 arg1 = static_cast< wxEventType >(val1);
20280 }
20281 if (obj1) {
20282 ecode2 = SWIG_AsVal_int(obj1, &val2);
20283 if (!SWIG_IsOK(ecode2)) {
20284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
20285 }
20286 arg2 = static_cast< int >(val2);
20287 }
20288 if (obj2) {
20289 ecode3 = SWIG_AsVal_int(obj2, &val3);
20290 if (!SWIG_IsOK(ecode3)) {
20291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
20292 }
20293 arg3 = static_cast< int >(val3);
20294 }
20295 if (obj3) {
20296 ecode4 = SWIG_AsVal_int(obj3, &val4);
20297 if (!SWIG_IsOK(ecode4)) {
20298 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
20299 }
20300 arg4 = static_cast< int >(val4);
20301 }
20302 {
20303 PyThreadState* __tstate = wxPyBeginAllowThreads();
20304 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
20305 wxPyEndAllowThreads(__tstate);
20306 if (PyErr_Occurred()) SWIG_fail;
20307 }
20308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
20309 return resultobj;
20310 fail:
20311 return NULL;
20312 }
20313
20314
20315 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *resultobj = 0;
20317 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20318 int result;
20319 void *argp1 = 0 ;
20320 int res1 = 0 ;
20321 PyObject *swig_obj[1] ;
20322
20323 if (!args) SWIG_fail;
20324 swig_obj[0] = args;
20325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20326 if (!SWIG_IsOK(res1)) {
20327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20328 }
20329 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 resultobj = SWIG_From_int(static_cast< int >(result));
20337 return resultobj;
20338 fail:
20339 return NULL;
20340 }
20341
20342
20343 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20346 int result;
20347 void *argp1 = 0 ;
20348 int res1 = 0 ;
20349 PyObject *swig_obj[1] ;
20350
20351 if (!args) SWIG_fail;
20352 swig_obj[0] = args;
20353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20354 if (!SWIG_IsOK(res1)) {
20355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
20356 }
20357 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20358 {
20359 PyThreadState* __tstate = wxPyBeginAllowThreads();
20360 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
20361 wxPyEndAllowThreads(__tstate);
20362 if (PyErr_Occurred()) SWIG_fail;
20363 }
20364 resultobj = SWIG_From_int(static_cast< int >(result));
20365 return resultobj;
20366 fail:
20367 return NULL;
20368 }
20369
20370
20371 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20372 PyObject *resultobj = 0;
20373 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20374 int arg2 ;
20375 void *argp1 = 0 ;
20376 int res1 = 0 ;
20377 int val2 ;
20378 int ecode2 = 0 ;
20379 PyObject * obj0 = 0 ;
20380 PyObject * obj1 = 0 ;
20381 char * kwnames[] = {
20382 (char *) "self",(char *) "orient", NULL
20383 };
20384
20385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20387 if (!SWIG_IsOK(res1)) {
20388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20389 }
20390 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20391 ecode2 = SWIG_AsVal_int(obj1, &val2);
20392 if (!SWIG_IsOK(ecode2)) {
20393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20394 }
20395 arg2 = static_cast< int >(val2);
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 (arg1)->SetOrientation(arg2);
20399 wxPyEndAllowThreads(__tstate);
20400 if (PyErr_Occurred()) SWIG_fail;
20401 }
20402 resultobj = SWIG_Py_Void();
20403 return resultobj;
20404 fail:
20405 return NULL;
20406 }
20407
20408
20409 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20410 PyObject *resultobj = 0;
20411 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
20412 int arg2 ;
20413 void *argp1 = 0 ;
20414 int res1 = 0 ;
20415 int val2 ;
20416 int ecode2 = 0 ;
20417 PyObject * obj0 = 0 ;
20418 PyObject * obj1 = 0 ;
20419 char * kwnames[] = {
20420 (char *) "self",(char *) "pos", NULL
20421 };
20422
20423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
20427 }
20428 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
20429 ecode2 = SWIG_AsVal_int(obj1, &val2);
20430 if (!SWIG_IsOK(ecode2)) {
20431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20432 }
20433 arg2 = static_cast< int >(val2);
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 (arg1)->SetPosition(arg2);
20437 wxPyEndAllowThreads(__tstate);
20438 if (PyErr_Occurred()) SWIG_fail;
20439 }
20440 resultobj = SWIG_Py_Void();
20441 return resultobj;
20442 fail:
20443 return NULL;
20444 }
20445
20446
20447 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20448 PyObject *obj;
20449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20450 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
20451 return SWIG_Py_Void();
20452 }
20453
20454 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20455 return SWIG_Python_InitShadowInstance(args);
20456 }
20457
20458 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20459 PyObject *resultobj = 0;
20460 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20461 int arg2 = (int) 0 ;
20462 int arg3 = (int) 0 ;
20463 wxScrollWinEvent *result = 0 ;
20464 int val1 ;
20465 int ecode1 = 0 ;
20466 int val2 ;
20467 int ecode2 = 0 ;
20468 int val3 ;
20469 int ecode3 = 0 ;
20470 PyObject * obj0 = 0 ;
20471 PyObject * obj1 = 0 ;
20472 PyObject * obj2 = 0 ;
20473 char * kwnames[] = {
20474 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20475 };
20476
20477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20478 if (obj0) {
20479 ecode1 = SWIG_AsVal_int(obj0, &val1);
20480 if (!SWIG_IsOK(ecode1)) {
20481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20482 }
20483 arg1 = static_cast< wxEventType >(val1);
20484 }
20485 if (obj1) {
20486 ecode2 = SWIG_AsVal_int(obj1, &val2);
20487 if (!SWIG_IsOK(ecode2)) {
20488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20489 }
20490 arg2 = static_cast< int >(val2);
20491 }
20492 if (obj2) {
20493 ecode3 = SWIG_AsVal_int(obj2, &val3);
20494 if (!SWIG_IsOK(ecode3)) {
20495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20496 }
20497 arg3 = static_cast< int >(val3);
20498 }
20499 {
20500 PyThreadState* __tstate = wxPyBeginAllowThreads();
20501 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20502 wxPyEndAllowThreads(__tstate);
20503 if (PyErr_Occurred()) SWIG_fail;
20504 }
20505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *resultobj = 0;
20514 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20515 int result;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject *swig_obj[1] ;
20519
20520 if (!args) SWIG_fail;
20521 swig_obj[0] = args;
20522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20525 }
20526 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 resultobj = SWIG_From_int(static_cast< int >(result));
20534 return resultobj;
20535 fail:
20536 return NULL;
20537 }
20538
20539
20540 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20541 PyObject *resultobj = 0;
20542 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20543 int result;
20544 void *argp1 = 0 ;
20545 int res1 = 0 ;
20546 PyObject *swig_obj[1] ;
20547
20548 if (!args) SWIG_fail;
20549 swig_obj[0] = args;
20550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20551 if (!SWIG_IsOK(res1)) {
20552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20553 }
20554 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 resultobj = SWIG_From_int(static_cast< int >(result));
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20569 PyObject *resultobj = 0;
20570 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20571 int arg2 ;
20572 void *argp1 = 0 ;
20573 int res1 = 0 ;
20574 int val2 ;
20575 int ecode2 = 0 ;
20576 PyObject * obj0 = 0 ;
20577 PyObject * obj1 = 0 ;
20578 char * kwnames[] = {
20579 (char *) "self",(char *) "orient", NULL
20580 };
20581
20582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20584 if (!SWIG_IsOK(res1)) {
20585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20586 }
20587 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20588 ecode2 = SWIG_AsVal_int(obj1, &val2);
20589 if (!SWIG_IsOK(ecode2)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20591 }
20592 arg2 = static_cast< int >(val2);
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 (arg1)->SetOrientation(arg2);
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 resultobj = SWIG_Py_Void();
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20607 PyObject *resultobj = 0;
20608 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20609 int arg2 ;
20610 void *argp1 = 0 ;
20611 int res1 = 0 ;
20612 int val2 ;
20613 int ecode2 = 0 ;
20614 PyObject * obj0 = 0 ;
20615 PyObject * obj1 = 0 ;
20616 char * kwnames[] = {
20617 (char *) "self",(char *) "pos", NULL
20618 };
20619
20620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20622 if (!SWIG_IsOK(res1)) {
20623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20624 }
20625 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20626 ecode2 = SWIG_AsVal_int(obj1, &val2);
20627 if (!SWIG_IsOK(ecode2)) {
20628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20629 }
20630 arg2 = static_cast< int >(val2);
20631 {
20632 PyThreadState* __tstate = wxPyBeginAllowThreads();
20633 (arg1)->SetPosition(arg2);
20634 wxPyEndAllowThreads(__tstate);
20635 if (PyErr_Occurred()) SWIG_fail;
20636 }
20637 resultobj = SWIG_Py_Void();
20638 return resultobj;
20639 fail:
20640 return NULL;
20641 }
20642
20643
20644 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20645 PyObject *obj;
20646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20647 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20648 return SWIG_Py_Void();
20649 }
20650
20651 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20652 return SWIG_Python_InitShadowInstance(args);
20653 }
20654
20655 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20656 PyObject *resultobj = 0;
20657 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20658 wxMouseEvent *result = 0 ;
20659 int val1 ;
20660 int ecode1 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 char * kwnames[] = {
20663 (char *) "mouseType", NULL
20664 };
20665
20666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20667 if (obj0) {
20668 ecode1 = SWIG_AsVal_int(obj0, &val1);
20669 if (!SWIG_IsOK(ecode1)) {
20670 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20671 }
20672 arg1 = static_cast< wxEventType >(val1);
20673 }
20674 {
20675 PyThreadState* __tstate = wxPyBeginAllowThreads();
20676 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 {
20681 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20682 }
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20692 bool result;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 PyObject *swig_obj[1] ;
20696
20697 if (!args) SWIG_fail;
20698 swig_obj[0] = args;
20699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20702 }
20703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 {
20711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20712 }
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20722 int arg2 = (int) wxMOUSE_BTN_ANY ;
20723 bool result;
20724 void *argp1 = 0 ;
20725 int res1 = 0 ;
20726 int val2 ;
20727 int ecode2 = 0 ;
20728 PyObject * obj0 = 0 ;
20729 PyObject * obj1 = 0 ;
20730 char * kwnames[] = {
20731 (char *) "self",(char *) "but", NULL
20732 };
20733
20734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20736 if (!SWIG_IsOK(res1)) {
20737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20738 }
20739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20740 if (obj1) {
20741 ecode2 = SWIG_AsVal_int(obj1, &val2);
20742 if (!SWIG_IsOK(ecode2)) {
20743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20744 }
20745 arg2 = static_cast< int >(val2);
20746 }
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 {
20754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20755 }
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20763 PyObject *resultobj = 0;
20764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20765 int arg2 = (int) wxMOUSE_BTN_ANY ;
20766 bool result;
20767 void *argp1 = 0 ;
20768 int res1 = 0 ;
20769 int val2 ;
20770 int ecode2 = 0 ;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 char * kwnames[] = {
20774 (char *) "self",(char *) "but", NULL
20775 };
20776
20777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20781 }
20782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20783 if (obj1) {
20784 ecode2 = SWIG_AsVal_int(obj1, &val2);
20785 if (!SWIG_IsOK(ecode2)) {
20786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20787 }
20788 arg2 = static_cast< int >(val2);
20789 }
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 int arg2 = (int) wxMOUSE_BTN_ANY ;
20809 bool result;
20810 void *argp1 = 0 ;
20811 int res1 = 0 ;
20812 int val2 ;
20813 int ecode2 = 0 ;
20814 PyObject * obj0 = 0 ;
20815 PyObject * obj1 = 0 ;
20816 char * kwnames[] = {
20817 (char *) "self",(char *) "but", NULL
20818 };
20819
20820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20822 if (!SWIG_IsOK(res1)) {
20823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20824 }
20825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20826 if (obj1) {
20827 ecode2 = SWIG_AsVal_int(obj1, &val2);
20828 if (!SWIG_IsOK(ecode2)) {
20829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20830 }
20831 arg2 = static_cast< int >(val2);
20832 }
20833 {
20834 PyThreadState* __tstate = wxPyBeginAllowThreads();
20835 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 {
20840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj = 0;
20850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20851 int arg2 ;
20852 bool result;
20853 void *argp1 = 0 ;
20854 int res1 = 0 ;
20855 int val2 ;
20856 int ecode2 = 0 ;
20857 PyObject * obj0 = 0 ;
20858 PyObject * obj1 = 0 ;
20859 char * kwnames[] = {
20860 (char *) "self",(char *) "button", NULL
20861 };
20862
20863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20865 if (!SWIG_IsOK(res1)) {
20866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20867 }
20868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20869 ecode2 = SWIG_AsVal_int(obj1, &val2);
20870 if (!SWIG_IsOK(ecode2)) {
20871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20872 }
20873 arg2 = static_cast< int >(val2);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = 0;
20891 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20892 int arg2 ;
20893 bool result;
20894 void *argp1 = 0 ;
20895 int res1 = 0 ;
20896 int val2 ;
20897 int ecode2 = 0 ;
20898 PyObject * obj0 = 0 ;
20899 PyObject * obj1 = 0 ;
20900 char * kwnames[] = {
20901 (char *) "self",(char *) "but", NULL
20902 };
20903
20904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20908 }
20909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20910 ecode2 = SWIG_AsVal_int(obj1, &val2);
20911 if (!SWIG_IsOK(ecode2)) {
20912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20913 }
20914 arg2 = static_cast< int >(val2);
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 {
20922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20923 }
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20933 int result;
20934 void *argp1 = 0 ;
20935 int res1 = 0 ;
20936 PyObject *swig_obj[1] ;
20937
20938 if (!args) SWIG_fail;
20939 swig_obj[0] = args;
20940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20941 if (!SWIG_IsOK(res1)) {
20942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20943 }
20944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_From_int(static_cast< int >(result));
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *resultobj = 0;
20960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20961 bool result;
20962 void *argp1 = 0 ;
20963 int res1 = 0 ;
20964 PyObject *swig_obj[1] ;
20965
20966 if (!args) SWIG_fail;
20967 swig_obj[0] = args;
20968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20969 if (!SWIG_IsOK(res1)) {
20970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20971 }
20972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20973 {
20974 PyThreadState* __tstate = wxPyBeginAllowThreads();
20975 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 {
20980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20981 }
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20989 PyObject *resultobj = 0;
20990 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20991 bool result;
20992 void *argp1 = 0 ;
20993 int res1 = 0 ;
20994 PyObject *swig_obj[1] ;
20995
20996 if (!args) SWIG_fail;
20997 swig_obj[0] = args;
20998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20999 if (!SWIG_IsOK(res1)) {
21000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21001 }
21002 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 {
21010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21011 }
21012 return resultobj;
21013 fail:
21014 return NULL;
21015 }
21016
21017
21018 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21019 PyObject *resultobj = 0;
21020 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21021 bool result;
21022 void *argp1 = 0 ;
21023 int res1 = 0 ;
21024 PyObject *swig_obj[1] ;
21025
21026 if (!args) SWIG_fail;
21027 swig_obj[0] = args;
21028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21029 if (!SWIG_IsOK(res1)) {
21030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21031 }
21032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 {
21040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21041 }
21042 return resultobj;
21043 fail:
21044 return NULL;
21045 }
21046
21047
21048 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21049 PyObject *resultobj = 0;
21050 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21051 bool result;
21052 void *argp1 = 0 ;
21053 int res1 = 0 ;
21054 PyObject *swig_obj[1] ;
21055
21056 if (!args) SWIG_fail;
21057 swig_obj[0] = args;
21058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21059 if (!SWIG_IsOK(res1)) {
21060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21061 }
21062 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21063 {
21064 PyThreadState* __tstate = wxPyBeginAllowThreads();
21065 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
21066 wxPyEndAllowThreads(__tstate);
21067 if (PyErr_Occurred()) SWIG_fail;
21068 }
21069 {
21070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21071 }
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21079 PyObject *resultobj = 0;
21080 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21081 bool result;
21082 void *argp1 = 0 ;
21083 int res1 = 0 ;
21084 PyObject *swig_obj[1] ;
21085
21086 if (!args) SWIG_fail;
21087 swig_obj[0] = args;
21088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21089 if (!SWIG_IsOK(res1)) {
21090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21091 }
21092 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21093 {
21094 PyThreadState* __tstate = wxPyBeginAllowThreads();
21095 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 {
21100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21101 }
21102 return resultobj;
21103 fail:
21104 return NULL;
21105 }
21106
21107
21108 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21109 PyObject *resultobj = 0;
21110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21111 bool result;
21112 void *argp1 = 0 ;
21113 int res1 = 0 ;
21114 PyObject *swig_obj[1] ;
21115
21116 if (!args) SWIG_fail;
21117 swig_obj[0] = args;
21118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21119 if (!SWIG_IsOK(res1)) {
21120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21121 }
21122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 {
21130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21131 }
21132 return resultobj;
21133 fail:
21134 return NULL;
21135 }
21136
21137
21138 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21139 PyObject *resultobj = 0;
21140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21141 bool result;
21142 void *argp1 = 0 ;
21143 int res1 = 0 ;
21144 PyObject *swig_obj[1] ;
21145
21146 if (!args) SWIG_fail;
21147 swig_obj[0] = args;
21148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21149 if (!SWIG_IsOK(res1)) {
21150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21151 }
21152 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
21156 wxPyEndAllowThreads(__tstate);
21157 if (PyErr_Occurred()) SWIG_fail;
21158 }
21159 {
21160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21161 }
21162 return resultobj;
21163 fail:
21164 return NULL;
21165 }
21166
21167
21168 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21169 PyObject *resultobj = 0;
21170 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21171 bool result;
21172 void *argp1 = 0 ;
21173 int res1 = 0 ;
21174 PyObject *swig_obj[1] ;
21175
21176 if (!args) SWIG_fail;
21177 swig_obj[0] = args;
21178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21179 if (!SWIG_IsOK(res1)) {
21180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21181 }
21182 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 {
21190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21191 }
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21199 PyObject *resultobj = 0;
21200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21201 bool result;
21202 void *argp1 = 0 ;
21203 int res1 = 0 ;
21204 PyObject *swig_obj[1] ;
21205
21206 if (!args) SWIG_fail;
21207 swig_obj[0] = args;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 {
21214 PyThreadState* __tstate = wxPyBeginAllowThreads();
21215 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
21216 wxPyEndAllowThreads(__tstate);
21217 if (PyErr_Occurred()) SWIG_fail;
21218 }
21219 {
21220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21221 }
21222 return resultobj;
21223 fail:
21224 return NULL;
21225 }
21226
21227
21228 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21229 PyObject *resultobj = 0;
21230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21231 bool result;
21232 void *argp1 = 0 ;
21233 int res1 = 0 ;
21234 PyObject *swig_obj[1] ;
21235
21236 if (!args) SWIG_fail;
21237 swig_obj[0] = args;
21238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21239 if (!SWIG_IsOK(res1)) {
21240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21241 }
21242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21243 {
21244 PyThreadState* __tstate = wxPyBeginAllowThreads();
21245 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
21246 wxPyEndAllowThreads(__tstate);
21247 if (PyErr_Occurred()) SWIG_fail;
21248 }
21249 {
21250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21251 }
21252 return resultobj;
21253 fail:
21254 return NULL;
21255 }
21256
21257
21258 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21259 PyObject *resultobj = 0;
21260 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21261 bool result;
21262 void *argp1 = 0 ;
21263 int res1 = 0 ;
21264 PyObject *swig_obj[1] ;
21265
21266 if (!args) SWIG_fail;
21267 swig_obj[0] = args;
21268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21271 }
21272 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21273 {
21274 PyThreadState* __tstate = wxPyBeginAllowThreads();
21275 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 {
21280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21281 }
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21289 PyObject *resultobj = 0;
21290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21291 bool result;
21292 void *argp1 = 0 ;
21293 int res1 = 0 ;
21294 PyObject *swig_obj[1] ;
21295
21296 if (!args) SWIG_fail;
21297 swig_obj[0] = args;
21298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21299 if (!SWIG_IsOK(res1)) {
21300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21301 }
21302 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21303 {
21304 PyThreadState* __tstate = wxPyBeginAllowThreads();
21305 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 {
21310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21311 }
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 bool result;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 PyObject *swig_obj[1] ;
21325
21326 if (!args) SWIG_fail;
21327 swig_obj[0] = args;
21328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21329 if (!SWIG_IsOK(res1)) {
21330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21331 }
21332 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21333 {
21334 PyThreadState* __tstate = wxPyBeginAllowThreads();
21335 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 {
21340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21341 }
21342 return resultobj;
21343 fail:
21344 return NULL;
21345 }
21346
21347
21348 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21349 PyObject *resultobj = 0;
21350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21351 bool result;
21352 void *argp1 = 0 ;
21353 int res1 = 0 ;
21354 PyObject *swig_obj[1] ;
21355
21356 if (!args) SWIG_fail;
21357 swig_obj[0] = args;
21358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21361 }
21362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21363 {
21364 PyThreadState* __tstate = wxPyBeginAllowThreads();
21365 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
21366 wxPyEndAllowThreads(__tstate);
21367 if (PyErr_Occurred()) SWIG_fail;
21368 }
21369 {
21370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21371 }
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 PyObject *resultobj = 0;
21380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21381 bool result;
21382 void *argp1 = 0 ;
21383 int res1 = 0 ;
21384 PyObject *swig_obj[1] ;
21385
21386 if (!args) SWIG_fail;
21387 swig_obj[0] = args;
21388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21389 if (!SWIG_IsOK(res1)) {
21390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21391 }
21392 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 result = (bool)(arg1)->LeftIsDown();
21396 wxPyEndAllowThreads(__tstate);
21397 if (PyErr_Occurred()) SWIG_fail;
21398 }
21399 {
21400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21401 }
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21409 PyObject *resultobj = 0;
21410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21411 bool result;
21412 void *argp1 = 0 ;
21413 int res1 = 0 ;
21414 PyObject *swig_obj[1] ;
21415
21416 if (!args) SWIG_fail;
21417 swig_obj[0] = args;
21418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21419 if (!SWIG_IsOK(res1)) {
21420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21421 }
21422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = (bool)(arg1)->MiddleIsDown();
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 {
21430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21431 }
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21439 PyObject *resultobj = 0;
21440 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21441 bool result;
21442 void *argp1 = 0 ;
21443 int res1 = 0 ;
21444 PyObject *swig_obj[1] ;
21445
21446 if (!args) SWIG_fail;
21447 swig_obj[0] = args;
21448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21449 if (!SWIG_IsOK(res1)) {
21450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21451 }
21452 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (bool)(arg1)->RightIsDown();
21456 wxPyEndAllowThreads(__tstate);
21457 if (PyErr_Occurred()) SWIG_fail;
21458 }
21459 {
21460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21461 }
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21471 bool result;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 PyObject *swig_obj[1] ;
21475
21476 if (!args) SWIG_fail;
21477 swig_obj[0] = args;
21478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21479 if (!SWIG_IsOK(res1)) {
21480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21481 }
21482 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21483 {
21484 PyThreadState* __tstate = wxPyBeginAllowThreads();
21485 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21486 wxPyEndAllowThreads(__tstate);
21487 if (PyErr_Occurred()) SWIG_fail;
21488 }
21489 {
21490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21491 }
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21499 PyObject *resultobj = 0;
21500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21501 bool result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 PyObject *swig_obj[1] ;
21505
21506 if (!args) SWIG_fail;
21507 swig_obj[0] = args;
21508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21511 }
21512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21513 {
21514 PyThreadState* __tstate = wxPyBeginAllowThreads();
21515 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21516 wxPyEndAllowThreads(__tstate);
21517 if (PyErr_Occurred()) SWIG_fail;
21518 }
21519 {
21520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21521 }
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21529 PyObject *resultobj = 0;
21530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21531 bool result;
21532 void *argp1 = 0 ;
21533 int res1 = 0 ;
21534 PyObject *swig_obj[1] ;
21535
21536 if (!args) SWIG_fail;
21537 swig_obj[0] = args;
21538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 {
21544 PyThreadState* __tstate = wxPyBeginAllowThreads();
21545 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21546 wxPyEndAllowThreads(__tstate);
21547 if (PyErr_Occurred()) SWIG_fail;
21548 }
21549 {
21550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21551 }
21552 return resultobj;
21553 fail:
21554 return NULL;
21555 }
21556
21557
21558 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 PyObject *resultobj = 0;
21560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21561 bool result;
21562 void *argp1 = 0 ;
21563 int res1 = 0 ;
21564 PyObject *swig_obj[1] ;
21565
21566 if (!args) SWIG_fail;
21567 swig_obj[0] = args;
21568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21569 if (!SWIG_IsOK(res1)) {
21570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21571 }
21572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21573 {
21574 PyThreadState* __tstate = wxPyBeginAllowThreads();
21575 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21576 wxPyEndAllowThreads(__tstate);
21577 if (PyErr_Occurred()) SWIG_fail;
21578 }
21579 {
21580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21581 }
21582 return resultobj;
21583 fail:
21584 return NULL;
21585 }
21586
21587
21588 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 PyObject *resultobj = 0;
21590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21591 wxPoint result;
21592 void *argp1 = 0 ;
21593 int res1 = 0 ;
21594 PyObject *swig_obj[1] ;
21595
21596 if (!args) SWIG_fail;
21597 swig_obj[0] = args;
21598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21599 if (!SWIG_IsOK(res1)) {
21600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21601 }
21602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (arg1)->GetPosition();
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21617 PyObject *resultobj = 0;
21618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21619 long *arg2 = (long *) 0 ;
21620 long *arg3 = (long *) 0 ;
21621 void *argp1 = 0 ;
21622 int res1 = 0 ;
21623 long temp2 ;
21624 int res2 = SWIG_TMPOBJ ;
21625 long temp3 ;
21626 int res3 = SWIG_TMPOBJ ;
21627 PyObject *swig_obj[1] ;
21628
21629 arg2 = &temp2;
21630 arg3 = &temp3;
21631 if (!args) SWIG_fail;
21632 swig_obj[0] = args;
21633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21634 if (!SWIG_IsOK(res1)) {
21635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21636 }
21637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 (arg1)->GetPosition(arg2,arg3);
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_Py_Void();
21645 if (SWIG_IsTmpObj(res2)) {
21646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21647 } else {
21648 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21650 }
21651 if (SWIG_IsTmpObj(res3)) {
21652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21653 } else {
21654 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21656 }
21657 return resultobj;
21658 fail:
21659 return NULL;
21660 }
21661
21662
21663 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj = 0;
21665 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21666 wxDC *arg2 = 0 ;
21667 wxPoint result;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 void *argp2 = 0 ;
21671 int res2 = 0 ;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char * kwnames[] = {
21675 (char *) "self",(char *) "dc", NULL
21676 };
21677
21678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21680 if (!SWIG_IsOK(res1)) {
21681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21682 }
21683 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21684 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21685 if (!SWIG_IsOK(res2)) {
21686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21687 }
21688 if (!argp2) {
21689 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21690 }
21691 arg2 = reinterpret_cast< wxDC * >(argp2);
21692 {
21693 PyThreadState* __tstate = wxPyBeginAllowThreads();
21694 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21699 return resultobj;
21700 fail:
21701 return NULL;
21702 }
21703
21704
21705 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21706 PyObject *resultobj = 0;
21707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21708 int result;
21709 void *argp1 = 0 ;
21710 int res1 = 0 ;
21711 PyObject *swig_obj[1] ;
21712
21713 if (!args) SWIG_fail;
21714 swig_obj[0] = args;
21715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21716 if (!SWIG_IsOK(res1)) {
21717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21718 }
21719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (int)((wxMouseEvent const *)arg1)->GetX();
21723 wxPyEndAllowThreads(__tstate);
21724 if (PyErr_Occurred()) SWIG_fail;
21725 }
21726 resultobj = SWIG_From_int(static_cast< int >(result));
21727 return resultobj;
21728 fail:
21729 return NULL;
21730 }
21731
21732
21733 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 PyObject *resultobj = 0;
21735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21736 int result;
21737 void *argp1 = 0 ;
21738 int res1 = 0 ;
21739 PyObject *swig_obj[1] ;
21740
21741 if (!args) SWIG_fail;
21742 swig_obj[0] = args;
21743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21746 }
21747 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21748 {
21749 PyThreadState* __tstate = wxPyBeginAllowThreads();
21750 result = (int)((wxMouseEvent const *)arg1)->GetY();
21751 wxPyEndAllowThreads(__tstate);
21752 if (PyErr_Occurred()) SWIG_fail;
21753 }
21754 resultobj = SWIG_From_int(static_cast< int >(result));
21755 return resultobj;
21756 fail:
21757 return NULL;
21758 }
21759
21760
21761 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21762 PyObject *resultobj = 0;
21763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21764 int result;
21765 void *argp1 = 0 ;
21766 int res1 = 0 ;
21767 PyObject *swig_obj[1] ;
21768
21769 if (!args) SWIG_fail;
21770 swig_obj[0] = args;
21771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21772 if (!SWIG_IsOK(res1)) {
21773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21774 }
21775 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21776 {
21777 PyThreadState* __tstate = wxPyBeginAllowThreads();
21778 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21779 wxPyEndAllowThreads(__tstate);
21780 if (PyErr_Occurred()) SWIG_fail;
21781 }
21782 resultobj = SWIG_From_int(static_cast< int >(result));
21783 return resultobj;
21784 fail:
21785 return NULL;
21786 }
21787
21788
21789 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21790 PyObject *resultobj = 0;
21791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21792 int result;
21793 void *argp1 = 0 ;
21794 int res1 = 0 ;
21795 PyObject *swig_obj[1] ;
21796
21797 if (!args) SWIG_fail;
21798 swig_obj[0] = args;
21799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21800 if (!SWIG_IsOK(res1)) {
21801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21802 }
21803 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21804 {
21805 PyThreadState* __tstate = wxPyBeginAllowThreads();
21806 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21807 wxPyEndAllowThreads(__tstate);
21808 if (PyErr_Occurred()) SWIG_fail;
21809 }
21810 resultobj = SWIG_From_int(static_cast< int >(result));
21811 return resultobj;
21812 fail:
21813 return NULL;
21814 }
21815
21816
21817 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21818 PyObject *resultobj = 0;
21819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21820 int result;
21821 void *argp1 = 0 ;
21822 int res1 = 0 ;
21823 PyObject *swig_obj[1] ;
21824
21825 if (!args) SWIG_fail;
21826 swig_obj[0] = args;
21827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21828 if (!SWIG_IsOK(res1)) {
21829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21830 }
21831 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21832 {
21833 PyThreadState* __tstate = wxPyBeginAllowThreads();
21834 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 resultobj = SWIG_From_int(static_cast< int >(result));
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21846 PyObject *resultobj = 0;
21847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21848 bool result;
21849 void *argp1 = 0 ;
21850 int res1 = 0 ;
21851 PyObject *swig_obj[1] ;
21852
21853 if (!args) SWIG_fail;
21854 swig_obj[0] = args;
21855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21856 if (!SWIG_IsOK(res1)) {
21857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21858 }
21859 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21863 wxPyEndAllowThreads(__tstate);
21864 if (PyErr_Occurred()) SWIG_fail;
21865 }
21866 {
21867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21868 }
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21876 PyObject *resultobj = 0;
21877 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21878 int arg2 ;
21879 void *argp1 = 0 ;
21880 int res1 = 0 ;
21881 int val2 ;
21882 int ecode2 = 0 ;
21883 PyObject *swig_obj[2] ;
21884
21885 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21887 if (!SWIG_IsOK(res1)) {
21888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21889 }
21890 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21891 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21892 if (!SWIG_IsOK(ecode2)) {
21893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21894 }
21895 arg2 = static_cast< int >(val2);
21896 if (arg1) (arg1)->m_x = arg2;
21897
21898 resultobj = SWIG_Py_Void();
21899 return resultobj;
21900 fail:
21901 return NULL;
21902 }
21903
21904
21905 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21906 PyObject *resultobj = 0;
21907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21908 int result;
21909 void *argp1 = 0 ;
21910 int res1 = 0 ;
21911 PyObject *swig_obj[1] ;
21912
21913 if (!args) SWIG_fail;
21914 swig_obj[0] = args;
21915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21916 if (!SWIG_IsOK(res1)) {
21917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21918 }
21919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21920 result = (int) ((arg1)->m_x);
21921 resultobj = SWIG_From_int(static_cast< int >(result));
21922 return resultobj;
21923 fail:
21924 return NULL;
21925 }
21926
21927
21928 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21929 PyObject *resultobj = 0;
21930 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21931 int arg2 ;
21932 void *argp1 = 0 ;
21933 int res1 = 0 ;
21934 int val2 ;
21935 int ecode2 = 0 ;
21936 PyObject *swig_obj[2] ;
21937
21938 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21942 }
21943 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21944 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21945 if (!SWIG_IsOK(ecode2)) {
21946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21947 }
21948 arg2 = static_cast< int >(val2);
21949 if (arg1) (arg1)->m_y = arg2;
21950
21951 resultobj = SWIG_Py_Void();
21952 return resultobj;
21953 fail:
21954 return NULL;
21955 }
21956
21957
21958 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21959 PyObject *resultobj = 0;
21960 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21961 int result;
21962 void *argp1 = 0 ;
21963 int res1 = 0 ;
21964 PyObject *swig_obj[1] ;
21965
21966 if (!args) SWIG_fail;
21967 swig_obj[0] = args;
21968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21969 if (!SWIG_IsOK(res1)) {
21970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21971 }
21972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21973 result = (int) ((arg1)->m_y);
21974 resultobj = SWIG_From_int(static_cast< int >(result));
21975 return resultobj;
21976 fail:
21977 return NULL;
21978 }
21979
21980
21981 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21982 PyObject *resultobj = 0;
21983 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21984 bool arg2 ;
21985 void *argp1 = 0 ;
21986 int res1 = 0 ;
21987 bool val2 ;
21988 int ecode2 = 0 ;
21989 PyObject *swig_obj[2] ;
21990
21991 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21993 if (!SWIG_IsOK(res1)) {
21994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21995 }
21996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21997 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21998 if (!SWIG_IsOK(ecode2)) {
21999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
22000 }
22001 arg2 = static_cast< bool >(val2);
22002 if (arg1) (arg1)->m_leftDown = arg2;
22003
22004 resultobj = SWIG_Py_Void();
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22012 PyObject *resultobj = 0;
22013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22014 bool result;
22015 void *argp1 = 0 ;
22016 int res1 = 0 ;
22017 PyObject *swig_obj[1] ;
22018
22019 if (!args) SWIG_fail;
22020 swig_obj[0] = args;
22021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22022 if (!SWIG_IsOK(res1)) {
22023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22024 }
22025 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22026 result = (bool) ((arg1)->m_leftDown);
22027 {
22028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22029 }
22030 return resultobj;
22031 fail:
22032 return NULL;
22033 }
22034
22035
22036 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22037 PyObject *resultobj = 0;
22038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22039 bool arg2 ;
22040 void *argp1 = 0 ;
22041 int res1 = 0 ;
22042 bool val2 ;
22043 int ecode2 = 0 ;
22044 PyObject *swig_obj[2] ;
22045
22046 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
22047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22050 }
22051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22052 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22053 if (!SWIG_IsOK(ecode2)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
22055 }
22056 arg2 = static_cast< bool >(val2);
22057 if (arg1) (arg1)->m_middleDown = arg2;
22058
22059 resultobj = SWIG_Py_Void();
22060 return resultobj;
22061 fail:
22062 return NULL;
22063 }
22064
22065
22066 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22067 PyObject *resultobj = 0;
22068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22069 bool result;
22070 void *argp1 = 0 ;
22071 int res1 = 0 ;
22072 PyObject *swig_obj[1] ;
22073
22074 if (!args) SWIG_fail;
22075 swig_obj[0] = args;
22076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22079 }
22080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22081 result = (bool) ((arg1)->m_middleDown);
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22092 PyObject *resultobj = 0;
22093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22094 bool arg2 ;
22095 void *argp1 = 0 ;
22096 int res1 = 0 ;
22097 bool val2 ;
22098 int ecode2 = 0 ;
22099 PyObject *swig_obj[2] ;
22100
22101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
22102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22103 if (!SWIG_IsOK(res1)) {
22104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22105 }
22106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22107 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22108 if (!SWIG_IsOK(ecode2)) {
22109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
22110 }
22111 arg2 = static_cast< bool >(val2);
22112 if (arg1) (arg1)->m_rightDown = arg2;
22113
22114 resultobj = SWIG_Py_Void();
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 PyObject *resultobj = 0;
22123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22124 bool result;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject *swig_obj[1] ;
22128
22129 if (!args) SWIG_fail;
22130 swig_obj[0] = args;
22131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22132 if (!SWIG_IsOK(res1)) {
22133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22134 }
22135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22136 result = (bool) ((arg1)->m_rightDown);
22137 {
22138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22139 }
22140 return resultobj;
22141 fail:
22142 return NULL;
22143 }
22144
22145
22146 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22147 PyObject *resultobj = 0;
22148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22149 bool arg2 ;
22150 void *argp1 = 0 ;
22151 int res1 = 0 ;
22152 bool val2 ;
22153 int ecode2 = 0 ;
22154 PyObject *swig_obj[2] ;
22155
22156 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22162 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22163 if (!SWIG_IsOK(ecode2)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22165 }
22166 arg2 = static_cast< bool >(val2);
22167 if (arg1) (arg1)->m_controlDown = arg2;
22168
22169 resultobj = SWIG_Py_Void();
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22177 PyObject *resultobj = 0;
22178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22179 bool result;
22180 void *argp1 = 0 ;
22181 int res1 = 0 ;
22182 PyObject *swig_obj[1] ;
22183
22184 if (!args) SWIG_fail;
22185 swig_obj[0] = args;
22186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22187 if (!SWIG_IsOK(res1)) {
22188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22189 }
22190 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22191 result = (bool) ((arg1)->m_controlDown);
22192 {
22193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22194 }
22195 return resultobj;
22196 fail:
22197 return NULL;
22198 }
22199
22200
22201 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22202 PyObject *resultobj = 0;
22203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22204 bool arg2 ;
22205 void *argp1 = 0 ;
22206 int res1 = 0 ;
22207 bool val2 ;
22208 int ecode2 = 0 ;
22209 PyObject *swig_obj[2] ;
22210
22211 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22213 if (!SWIG_IsOK(res1)) {
22214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22215 }
22216 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22217 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22218 if (!SWIG_IsOK(ecode2)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22220 }
22221 arg2 = static_cast< bool >(val2);
22222 if (arg1) (arg1)->m_shiftDown = arg2;
22223
22224 resultobj = SWIG_Py_Void();
22225 return resultobj;
22226 fail:
22227 return NULL;
22228 }
22229
22230
22231 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22232 PyObject *resultobj = 0;
22233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22234 bool result;
22235 void *argp1 = 0 ;
22236 int res1 = 0 ;
22237 PyObject *swig_obj[1] ;
22238
22239 if (!args) SWIG_fail;
22240 swig_obj[0] = args;
22241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22242 if (!SWIG_IsOK(res1)) {
22243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22244 }
22245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22246 result = (bool) ((arg1)->m_shiftDown);
22247 {
22248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22249 }
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22257 PyObject *resultobj = 0;
22258 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22259 bool arg2 ;
22260 void *argp1 = 0 ;
22261 int res1 = 0 ;
22262 bool val2 ;
22263 int ecode2 = 0 ;
22264 PyObject *swig_obj[2] ;
22265
22266 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22268 if (!SWIG_IsOK(res1)) {
22269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22270 }
22271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22272 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22275 }
22276 arg2 = static_cast< bool >(val2);
22277 if (arg1) (arg1)->m_altDown = arg2;
22278
22279 resultobj = SWIG_Py_Void();
22280 return resultobj;
22281 fail:
22282 return NULL;
22283 }
22284
22285
22286 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 PyObject *resultobj = 0;
22288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22289 bool result;
22290 void *argp1 = 0 ;
22291 int res1 = 0 ;
22292 PyObject *swig_obj[1] ;
22293
22294 if (!args) SWIG_fail;
22295 swig_obj[0] = args;
22296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22297 if (!SWIG_IsOK(res1)) {
22298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22299 }
22300 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22301 result = (bool) ((arg1)->m_altDown);
22302 {
22303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22304 }
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22314 bool arg2 ;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 bool val2 ;
22318 int ecode2 = 0 ;
22319 PyObject *swig_obj[2] ;
22320
22321 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22323 if (!SWIG_IsOK(res1)) {
22324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22325 }
22326 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22327 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22328 if (!SWIG_IsOK(ecode2)) {
22329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22330 }
22331 arg2 = static_cast< bool >(val2);
22332 if (arg1) (arg1)->m_metaDown = arg2;
22333
22334 resultobj = SWIG_Py_Void();
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22342 PyObject *resultobj = 0;
22343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22344 bool result;
22345 void *argp1 = 0 ;
22346 int res1 = 0 ;
22347 PyObject *swig_obj[1] ;
22348
22349 if (!args) SWIG_fail;
22350 swig_obj[0] = args;
22351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22352 if (!SWIG_IsOK(res1)) {
22353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22354 }
22355 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22356 result = (bool) ((arg1)->m_metaDown);
22357 {
22358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22359 }
22360 return resultobj;
22361 fail:
22362 return NULL;
22363 }
22364
22365
22366 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22367 PyObject *resultobj = 0;
22368 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22369 int arg2 ;
22370 void *argp1 = 0 ;
22371 int res1 = 0 ;
22372 int val2 ;
22373 int ecode2 = 0 ;
22374 PyObject *swig_obj[2] ;
22375
22376 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
22377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22378 if (!SWIG_IsOK(res1)) {
22379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22380 }
22381 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22382 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22383 if (!SWIG_IsOK(ecode2)) {
22384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
22385 }
22386 arg2 = static_cast< int >(val2);
22387 if (arg1) (arg1)->m_wheelRotation = arg2;
22388
22389 resultobj = SWIG_Py_Void();
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22397 PyObject *resultobj = 0;
22398 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22399 int result;
22400 void *argp1 = 0 ;
22401 int res1 = 0 ;
22402 PyObject *swig_obj[1] ;
22403
22404 if (!args) SWIG_fail;
22405 swig_obj[0] = args;
22406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22407 if (!SWIG_IsOK(res1)) {
22408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22409 }
22410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22411 result = (int) ((arg1)->m_wheelRotation);
22412 resultobj = SWIG_From_int(static_cast< int >(result));
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22420 PyObject *resultobj = 0;
22421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22422 int arg2 ;
22423 void *argp1 = 0 ;
22424 int res1 = 0 ;
22425 int val2 ;
22426 int ecode2 = 0 ;
22427 PyObject *swig_obj[2] ;
22428
22429 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
22430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22431 if (!SWIG_IsOK(res1)) {
22432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22433 }
22434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22435 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22436 if (!SWIG_IsOK(ecode2)) {
22437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
22438 }
22439 arg2 = static_cast< int >(val2);
22440 if (arg1) (arg1)->m_wheelDelta = arg2;
22441
22442 resultobj = SWIG_Py_Void();
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22450 PyObject *resultobj = 0;
22451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22452 int result;
22453 void *argp1 = 0 ;
22454 int res1 = 0 ;
22455 PyObject *swig_obj[1] ;
22456
22457 if (!args) SWIG_fail;
22458 swig_obj[0] = args;
22459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22460 if (!SWIG_IsOK(res1)) {
22461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22462 }
22463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22464 result = (int) ((arg1)->m_wheelDelta);
22465 resultobj = SWIG_From_int(static_cast< int >(result));
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22475 int arg2 ;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 int val2 ;
22479 int ecode2 = 0 ;
22480 PyObject *swig_obj[2] ;
22481
22482 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22484 if (!SWIG_IsOK(res1)) {
22485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22486 }
22487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22488 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22489 if (!SWIG_IsOK(ecode2)) {
22490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22491 }
22492 arg2 = static_cast< int >(val2);
22493 if (arg1) (arg1)->m_linesPerAction = arg2;
22494
22495 resultobj = SWIG_Py_Void();
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22503 PyObject *resultobj = 0;
22504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22505 int result;
22506 void *argp1 = 0 ;
22507 int res1 = 0 ;
22508 PyObject *swig_obj[1] ;
22509
22510 if (!args) SWIG_fail;
22511 swig_obj[0] = args;
22512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22513 if (!SWIG_IsOK(res1)) {
22514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22515 }
22516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22517 result = (int) ((arg1)->m_linesPerAction);
22518 resultobj = SWIG_From_int(static_cast< int >(result));
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *obj;
22527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22528 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22529 return SWIG_Py_Void();
22530 }
22531
22532 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22533 return SWIG_Python_InitShadowInstance(args);
22534 }
22535
22536 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 int arg1 = (int) 0 ;
22539 int arg2 = (int) 0 ;
22540 wxSetCursorEvent *result = 0 ;
22541 int val1 ;
22542 int ecode1 = 0 ;
22543 int val2 ;
22544 int ecode2 = 0 ;
22545 PyObject * obj0 = 0 ;
22546 PyObject * obj1 = 0 ;
22547 char * kwnames[] = {
22548 (char *) "x",(char *) "y", NULL
22549 };
22550
22551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22552 if (obj0) {
22553 ecode1 = SWIG_AsVal_int(obj0, &val1);
22554 if (!SWIG_IsOK(ecode1)) {
22555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22556 }
22557 arg1 = static_cast< int >(val1);
22558 }
22559 if (obj1) {
22560 ecode2 = SWIG_AsVal_int(obj1, &val2);
22561 if (!SWIG_IsOK(ecode2)) {
22562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22563 }
22564 arg2 = static_cast< int >(val2);
22565 }
22566 {
22567 PyThreadState* __tstate = wxPyBeginAllowThreads();
22568 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22573 return resultobj;
22574 fail:
22575 return NULL;
22576 }
22577
22578
22579 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22580 PyObject *resultobj = 0;
22581 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22582 int result;
22583 void *argp1 = 0 ;
22584 int res1 = 0 ;
22585 PyObject *swig_obj[1] ;
22586
22587 if (!args) SWIG_fail;
22588 swig_obj[0] = args;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22592 }
22593 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_From_int(static_cast< int >(result));
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22610 int result;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 PyObject *swig_obj[1] ;
22614
22615 if (!args) SWIG_fail;
22616 swig_obj[0] = args;
22617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22620 }
22621 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 resultobj = SWIG_From_int(static_cast< int >(result));
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22636 PyObject *resultobj = 0;
22637 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22638 wxCursor *arg2 = 0 ;
22639 void *argp1 = 0 ;
22640 int res1 = 0 ;
22641 void *argp2 = 0 ;
22642 int res2 = 0 ;
22643 PyObject * obj0 = 0 ;
22644 PyObject * obj1 = 0 ;
22645 char * kwnames[] = {
22646 (char *) "self",(char *) "cursor", NULL
22647 };
22648
22649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22655 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22656 if (!SWIG_IsOK(res2)) {
22657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22658 }
22659 if (!argp2) {
22660 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22661 }
22662 arg2 = reinterpret_cast< wxCursor * >(argp2);
22663 {
22664 PyThreadState* __tstate = wxPyBeginAllowThreads();
22665 (arg1)->SetCursor((wxCursor const &)*arg2);
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_Py_Void();
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22679 wxCursor *result = 0 ;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22689 }
22690 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 {
22694 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22695 result = (wxCursor *) &_result_ref;
22696 }
22697 wxPyEndAllowThreads(__tstate);
22698 if (PyErr_Occurred()) SWIG_fail;
22699 }
22700 {
22701 wxCursor* resultptr = new wxCursor(*result);
22702 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22703 }
22704 return resultobj;
22705 fail:
22706 return NULL;
22707 }
22708
22709
22710 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22711 PyObject *resultobj = 0;
22712 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22713 bool result;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 PyObject *swig_obj[1] ;
22717
22718 if (!args) SWIG_fail;
22719 swig_obj[0] = args;
22720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22721 if (!SWIG_IsOK(res1)) {
22722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22723 }
22724 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22725 {
22726 PyThreadState* __tstate = wxPyBeginAllowThreads();
22727 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 {
22732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22733 }
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22741 PyObject *obj;
22742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22743 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22744 return SWIG_Py_Void();
22745 }
22746
22747 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22748 return SWIG_Python_InitShadowInstance(args);
22749 }
22750
22751 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22752 PyObject *resultobj = 0;
22753 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22754 wxKeyEvent *result = 0 ;
22755 int val1 ;
22756 int ecode1 = 0 ;
22757 PyObject * obj0 = 0 ;
22758 char * kwnames[] = {
22759 (char *) "eventType", NULL
22760 };
22761
22762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22763 if (obj0) {
22764 ecode1 = SWIG_AsVal_int(obj0, &val1);
22765 if (!SWIG_IsOK(ecode1)) {
22766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22767 }
22768 arg1 = static_cast< wxEventType >(val1);
22769 }
22770 {
22771 PyThreadState* __tstate = wxPyBeginAllowThreads();
22772 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22773 wxPyEndAllowThreads(__tstate);
22774 if (PyErr_Occurred()) SWIG_fail;
22775 }
22776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22777 return resultobj;
22778 fail:
22779 return NULL;
22780 }
22781
22782
22783 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22784 PyObject *resultobj = 0;
22785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22786 int result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 PyObject *swig_obj[1] ;
22790
22791 if (!args) SWIG_fail;
22792 swig_obj[0] = args;
22793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22794 if (!SWIG_IsOK(res1)) {
22795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22796 }
22797 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22798 {
22799 PyThreadState* __tstate = wxPyBeginAllowThreads();
22800 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 resultobj = SWIG_From_int(static_cast< int >(result));
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22812 PyObject *resultobj = 0;
22813 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22814 bool result;
22815 void *argp1 = 0 ;
22816 int res1 = 0 ;
22817 PyObject *swig_obj[1] ;
22818
22819 if (!args) SWIG_fail;
22820 swig_obj[0] = args;
22821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22822 if (!SWIG_IsOK(res1)) {
22823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22824 }
22825 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22826 {
22827 PyThreadState* __tstate = wxPyBeginAllowThreads();
22828 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22829 wxPyEndAllowThreads(__tstate);
22830 if (PyErr_Occurred()) SWIG_fail;
22831 }
22832 {
22833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22834 }
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22842 PyObject *resultobj = 0;
22843 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22844 bool result;
22845 void *argp1 = 0 ;
22846 int res1 = 0 ;
22847 PyObject *swig_obj[1] ;
22848
22849 if (!args) SWIG_fail;
22850 swig_obj[0] = args;
22851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22852 if (!SWIG_IsOK(res1)) {
22853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22854 }
22855 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22856 {
22857 PyThreadState* __tstate = wxPyBeginAllowThreads();
22858 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 {
22863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22874 bool result;
22875 void *argp1 = 0 ;
22876 int res1 = 0 ;
22877 PyObject *swig_obj[1] ;
22878
22879 if (!args) SWIG_fail;
22880 swig_obj[0] = args;
22881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22882 if (!SWIG_IsOK(res1)) {
22883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22884 }
22885 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22886 {
22887 PyThreadState* __tstate = wxPyBeginAllowThreads();
22888 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22889 wxPyEndAllowThreads(__tstate);
22890 if (PyErr_Occurred()) SWIG_fail;
22891 }
22892 {
22893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22894 }
22895 return resultobj;
22896 fail:
22897 return NULL;
22898 }
22899
22900
22901 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22902 PyObject *resultobj = 0;
22903 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22904 bool result;
22905 void *argp1 = 0 ;
22906 int res1 = 0 ;
22907 PyObject *swig_obj[1] ;
22908
22909 if (!args) SWIG_fail;
22910 swig_obj[0] = args;
22911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22912 if (!SWIG_IsOK(res1)) {
22913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22914 }
22915 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22916 {
22917 PyThreadState* __tstate = wxPyBeginAllowThreads();
22918 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22919 wxPyEndAllowThreads(__tstate);
22920 if (PyErr_Occurred()) SWIG_fail;
22921 }
22922 {
22923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22924 }
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22932 PyObject *resultobj = 0;
22933 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22934 bool result;
22935 void *argp1 = 0 ;
22936 int res1 = 0 ;
22937 PyObject *swig_obj[1] ;
22938
22939 if (!args) SWIG_fail;
22940 swig_obj[0] = args;
22941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22954 }
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22962 PyObject *resultobj = 0;
22963 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22964 bool result;
22965 void *argp1 = 0 ;
22966 int res1 = 0 ;
22967 PyObject *swig_obj[1] ;
22968
22969 if (!args) SWIG_fail;
22970 swig_obj[0] = args;
22971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22972 if (!SWIG_IsOK(res1)) {
22973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22974 }
22975 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22992 PyObject *resultobj = 0;
22993 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22994 int result;
22995 void *argp1 = 0 ;
22996 int res1 = 0 ;
22997 PyObject *swig_obj[1] ;
22998
22999 if (!args) SWIG_fail;
23000 swig_obj[0] = args;
23001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23004 }
23005 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 resultobj = SWIG_From_int(static_cast< int >(result));
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23020 PyObject *resultobj = 0;
23021 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23022 int result;
23023 void *argp1 = 0 ;
23024 int res1 = 0 ;
23025 PyObject *swig_obj[1] ;
23026
23027 if (!args) SWIG_fail;
23028 swig_obj[0] = args;
23029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23030 if (!SWIG_IsOK(res1)) {
23031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23032 }
23033 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23034 {
23035 PyThreadState* __tstate = wxPyBeginAllowThreads();
23036 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 resultobj = SWIG_From_int(static_cast< int >(result));
23041 return resultobj;
23042 fail:
23043 return NULL;
23044 }
23045
23046
23047 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23048 PyObject *resultobj = 0;
23049 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23050 int arg2 ;
23051 void *argp1 = 0 ;
23052 int res1 = 0 ;
23053 int val2 ;
23054 int ecode2 = 0 ;
23055 PyObject * obj0 = 0 ;
23056 PyObject * obj1 = 0 ;
23057 char * kwnames[] = {
23058 (char *) "self",(char *) "uniChar", NULL
23059 };
23060
23061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
23062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23063 if (!SWIG_IsOK(res1)) {
23064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23065 }
23066 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23067 ecode2 = SWIG_AsVal_int(obj1, &val2);
23068 if (!SWIG_IsOK(ecode2)) {
23069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
23070 }
23071 arg2 = static_cast< int >(val2);
23072 {
23073 PyThreadState* __tstate = wxPyBeginAllowThreads();
23074 wxKeyEvent_SetUnicodeKey(arg1,arg2);
23075 wxPyEndAllowThreads(__tstate);
23076 if (PyErr_Occurred()) SWIG_fail;
23077 }
23078 resultobj = SWIG_Py_Void();
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23086 PyObject *resultobj = 0;
23087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23088 unsigned int result;
23089 void *argp1 = 0 ;
23090 int res1 = 0 ;
23091 PyObject *swig_obj[1] ;
23092
23093 if (!args) SWIG_fail;
23094 swig_obj[0] = args;
23095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23096 if (!SWIG_IsOK(res1)) {
23097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23098 }
23099 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23100 {
23101 PyThreadState* __tstate = wxPyBeginAllowThreads();
23102 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
23103 wxPyEndAllowThreads(__tstate);
23104 if (PyErr_Occurred()) SWIG_fail;
23105 }
23106 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23114 PyObject *resultobj = 0;
23115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23116 unsigned int result;
23117 void *argp1 = 0 ;
23118 int res1 = 0 ;
23119 PyObject *swig_obj[1] ;
23120
23121 if (!args) SWIG_fail;
23122 swig_obj[0] = args;
23123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23124 if (!SWIG_IsOK(res1)) {
23125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23126 }
23127 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23128 {
23129 PyThreadState* __tstate = wxPyBeginAllowThreads();
23130 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
23131 wxPyEndAllowThreads(__tstate);
23132 if (PyErr_Occurred()) SWIG_fail;
23133 }
23134 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23144 wxPoint result;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 PyObject *swig_obj[1] ;
23148
23149 if (!args) SWIG_fail;
23150 swig_obj[0] = args;
23151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23154 }
23155 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (arg1)->GetPosition();
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23170 PyObject *resultobj = 0;
23171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23172 long *arg2 = (long *) 0 ;
23173 long *arg3 = (long *) 0 ;
23174 void *argp1 = 0 ;
23175 int res1 = 0 ;
23176 long temp2 ;
23177 int res2 = SWIG_TMPOBJ ;
23178 long temp3 ;
23179 int res3 = SWIG_TMPOBJ ;
23180 PyObject *swig_obj[1] ;
23181
23182 arg2 = &temp2;
23183 arg3 = &temp3;
23184 if (!args) SWIG_fail;
23185 swig_obj[0] = args;
23186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23187 if (!SWIG_IsOK(res1)) {
23188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23189 }
23190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 (arg1)->GetPosition(arg2,arg3);
23194 wxPyEndAllowThreads(__tstate);
23195 if (PyErr_Occurred()) SWIG_fail;
23196 }
23197 resultobj = SWIG_Py_Void();
23198 if (SWIG_IsTmpObj(res2)) {
23199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23200 } else {
23201 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23203 }
23204 if (SWIG_IsTmpObj(res3)) {
23205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23206 } else {
23207 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23209 }
23210 return resultobj;
23211 fail:
23212 return NULL;
23213 }
23214
23215
23216 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23217 PyObject *resultobj = 0;
23218 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23219 int result;
23220 void *argp1 = 0 ;
23221 int res1 = 0 ;
23222 PyObject *swig_obj[1] ;
23223
23224 if (!args) SWIG_fail;
23225 swig_obj[0] = args;
23226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23227 if (!SWIG_IsOK(res1)) {
23228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23229 }
23230 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (int)((wxKeyEvent const *)arg1)->GetX();
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 resultobj = SWIG_From_int(static_cast< int >(result));
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23245 PyObject *resultobj = 0;
23246 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23247 int result;
23248 void *argp1 = 0 ;
23249 int res1 = 0 ;
23250 PyObject *swig_obj[1] ;
23251
23252 if (!args) SWIG_fail;
23253 swig_obj[0] = args;
23254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
23257 }
23258 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (int)((wxKeyEvent const *)arg1)->GetY();
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 resultobj = SWIG_From_int(static_cast< int >(result));
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *resultobj = 0;
23274 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23275 int arg2 ;
23276 void *argp1 = 0 ;
23277 int res1 = 0 ;
23278 int val2 ;
23279 int ecode2 = 0 ;
23280 PyObject *swig_obj[2] ;
23281
23282 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23284 if (!SWIG_IsOK(res1)) {
23285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23286 }
23287 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23288 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23289 if (!SWIG_IsOK(ecode2)) {
23290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23291 }
23292 arg2 = static_cast< int >(val2);
23293 if (arg1) (arg1)->m_x = arg2;
23294
23295 resultobj = SWIG_Py_Void();
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23303 PyObject *resultobj = 0;
23304 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23305 int result;
23306 void *argp1 = 0 ;
23307 int res1 = 0 ;
23308 PyObject *swig_obj[1] ;
23309
23310 if (!args) SWIG_fail;
23311 swig_obj[0] = args;
23312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23313 if (!SWIG_IsOK(res1)) {
23314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23315 }
23316 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23317 result = (int) ((arg1)->m_x);
23318 resultobj = SWIG_From_int(static_cast< int >(result));
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23326 PyObject *resultobj = 0;
23327 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23328 int arg2 ;
23329 void *argp1 = 0 ;
23330 int res1 = 0 ;
23331 int val2 ;
23332 int ecode2 = 0 ;
23333 PyObject *swig_obj[2] ;
23334
23335 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
23336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23337 if (!SWIG_IsOK(res1)) {
23338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23339 }
23340 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23341 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23342 if (!SWIG_IsOK(ecode2)) {
23343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
23344 }
23345 arg2 = static_cast< int >(val2);
23346 if (arg1) (arg1)->m_y = arg2;
23347
23348 resultobj = SWIG_Py_Void();
23349 return resultobj;
23350 fail:
23351 return NULL;
23352 }
23353
23354
23355 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23356 PyObject *resultobj = 0;
23357 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23358 int result;
23359 void *argp1 = 0 ;
23360 int res1 = 0 ;
23361 PyObject *swig_obj[1] ;
23362
23363 if (!args) SWIG_fail;
23364 swig_obj[0] = args;
23365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23366 if (!SWIG_IsOK(res1)) {
23367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23368 }
23369 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23370 result = (int) ((arg1)->m_y);
23371 resultobj = SWIG_From_int(static_cast< int >(result));
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23379 PyObject *resultobj = 0;
23380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23381 long arg2 ;
23382 void *argp1 = 0 ;
23383 int res1 = 0 ;
23384 long val2 ;
23385 int ecode2 = 0 ;
23386 PyObject *swig_obj[2] ;
23387
23388 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
23389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23390 if (!SWIG_IsOK(res1)) {
23391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23392 }
23393 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23394 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
23395 if (!SWIG_IsOK(ecode2)) {
23396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
23397 }
23398 arg2 = static_cast< long >(val2);
23399 if (arg1) (arg1)->m_keyCode = arg2;
23400
23401 resultobj = SWIG_Py_Void();
23402 return resultobj;
23403 fail:
23404 return NULL;
23405 }
23406
23407
23408 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23409 PyObject *resultobj = 0;
23410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23411 long result;
23412 void *argp1 = 0 ;
23413 int res1 = 0 ;
23414 PyObject *swig_obj[1] ;
23415
23416 if (!args) SWIG_fail;
23417 swig_obj[0] = args;
23418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23419 if (!SWIG_IsOK(res1)) {
23420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23421 }
23422 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23423 result = (long) ((arg1)->m_keyCode);
23424 resultobj = SWIG_From_long(static_cast< long >(result));
23425 return resultobj;
23426 fail:
23427 return NULL;
23428 }
23429
23430
23431 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23432 PyObject *resultobj = 0;
23433 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23434 bool arg2 ;
23435 void *argp1 = 0 ;
23436 int res1 = 0 ;
23437 bool val2 ;
23438 int ecode2 = 0 ;
23439 PyObject *swig_obj[2] ;
23440
23441 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
23442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23443 if (!SWIG_IsOK(res1)) {
23444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23445 }
23446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23447 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23448 if (!SWIG_IsOK(ecode2)) {
23449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
23450 }
23451 arg2 = static_cast< bool >(val2);
23452 if (arg1) (arg1)->m_controlDown = arg2;
23453
23454 resultobj = SWIG_Py_Void();
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23462 PyObject *resultobj = 0;
23463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23464 bool result;
23465 void *argp1 = 0 ;
23466 int res1 = 0 ;
23467 PyObject *swig_obj[1] ;
23468
23469 if (!args) SWIG_fail;
23470 swig_obj[0] = args;
23471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23472 if (!SWIG_IsOK(res1)) {
23473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23474 }
23475 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23476 result = (bool) ((arg1)->m_controlDown);
23477 {
23478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23479 }
23480 return resultobj;
23481 fail:
23482 return NULL;
23483 }
23484
23485
23486 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23487 PyObject *resultobj = 0;
23488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23489 bool arg2 ;
23490 void *argp1 = 0 ;
23491 int res1 = 0 ;
23492 bool val2 ;
23493 int ecode2 = 0 ;
23494 PyObject *swig_obj[2] ;
23495
23496 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23498 if (!SWIG_IsOK(res1)) {
23499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23500 }
23501 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23502 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23503 if (!SWIG_IsOK(ecode2)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23505 }
23506 arg2 = static_cast< bool >(val2);
23507 if (arg1) (arg1)->m_shiftDown = arg2;
23508
23509 resultobj = SWIG_Py_Void();
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *resultobj = 0;
23518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23519 bool result;
23520 void *argp1 = 0 ;
23521 int res1 = 0 ;
23522 PyObject *swig_obj[1] ;
23523
23524 if (!args) SWIG_fail;
23525 swig_obj[0] = args;
23526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23527 if (!SWIG_IsOK(res1)) {
23528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23529 }
23530 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23531 result = (bool) ((arg1)->m_shiftDown);
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23542 PyObject *resultobj = 0;
23543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23544 bool arg2 ;
23545 void *argp1 = 0 ;
23546 int res1 = 0 ;
23547 bool val2 ;
23548 int ecode2 = 0 ;
23549 PyObject *swig_obj[2] ;
23550
23551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23553 if (!SWIG_IsOK(res1)) {
23554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23555 }
23556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23557 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23558 if (!SWIG_IsOK(ecode2)) {
23559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23560 }
23561 arg2 = static_cast< bool >(val2);
23562 if (arg1) (arg1)->m_altDown = arg2;
23563
23564 resultobj = SWIG_Py_Void();
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23572 PyObject *resultobj = 0;
23573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23574 bool result;
23575 void *argp1 = 0 ;
23576 int res1 = 0 ;
23577 PyObject *swig_obj[1] ;
23578
23579 if (!args) SWIG_fail;
23580 swig_obj[0] = args;
23581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23582 if (!SWIG_IsOK(res1)) {
23583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23584 }
23585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23586 result = (bool) ((arg1)->m_altDown);
23587 {
23588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23589 }
23590 return resultobj;
23591 fail:
23592 return NULL;
23593 }
23594
23595
23596 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23597 PyObject *resultobj = 0;
23598 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23599 bool arg2 ;
23600 void *argp1 = 0 ;
23601 int res1 = 0 ;
23602 bool val2 ;
23603 int ecode2 = 0 ;
23604 PyObject *swig_obj[2] ;
23605
23606 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23608 if (!SWIG_IsOK(res1)) {
23609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23610 }
23611 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23612 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23613 if (!SWIG_IsOK(ecode2)) {
23614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23615 }
23616 arg2 = static_cast< bool >(val2);
23617 if (arg1) (arg1)->m_metaDown = arg2;
23618
23619 resultobj = SWIG_Py_Void();
23620 return resultobj;
23621 fail:
23622 return NULL;
23623 }
23624
23625
23626 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23627 PyObject *resultobj = 0;
23628 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23629 bool result;
23630 void *argp1 = 0 ;
23631 int res1 = 0 ;
23632 PyObject *swig_obj[1] ;
23633
23634 if (!args) SWIG_fail;
23635 swig_obj[0] = args;
23636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23637 if (!SWIG_IsOK(res1)) {
23638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23639 }
23640 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23641 result = (bool) ((arg1)->m_metaDown);
23642 {
23643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 PyObject *resultobj = 0;
23653 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23654 bool arg2 ;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 bool val2 ;
23658 int ecode2 = 0 ;
23659 PyObject *swig_obj[2] ;
23660
23661 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23663 if (!SWIG_IsOK(res1)) {
23664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23665 }
23666 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23667 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23668 if (!SWIG_IsOK(ecode2)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23670 }
23671 arg2 = static_cast< bool >(val2);
23672 if (arg1) (arg1)->m_scanCode = arg2;
23673
23674 resultobj = SWIG_Py_Void();
23675 return resultobj;
23676 fail:
23677 return NULL;
23678 }
23679
23680
23681 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23682 PyObject *resultobj = 0;
23683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23684 bool result;
23685 void *argp1 = 0 ;
23686 int res1 = 0 ;
23687 PyObject *swig_obj[1] ;
23688
23689 if (!args) SWIG_fail;
23690 swig_obj[0] = args;
23691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23692 if (!SWIG_IsOK(res1)) {
23693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23694 }
23695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23696 result = (bool) ((arg1)->m_scanCode);
23697 {
23698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23699 }
23700 return resultobj;
23701 fail:
23702 return NULL;
23703 }
23704
23705
23706 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23707 PyObject *resultobj = 0;
23708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23709 unsigned int arg2 ;
23710 void *argp1 = 0 ;
23711 int res1 = 0 ;
23712 unsigned int val2 ;
23713 int ecode2 = 0 ;
23714 PyObject *swig_obj[2] ;
23715
23716 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23718 if (!SWIG_IsOK(res1)) {
23719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23720 }
23721 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23722 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23723 if (!SWIG_IsOK(ecode2)) {
23724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23725 }
23726 arg2 = static_cast< unsigned int >(val2);
23727 if (arg1) (arg1)->m_rawCode = arg2;
23728
23729 resultobj = SWIG_Py_Void();
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23737 PyObject *resultobj = 0;
23738 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23739 unsigned int result;
23740 void *argp1 = 0 ;
23741 int res1 = 0 ;
23742 PyObject *swig_obj[1] ;
23743
23744 if (!args) SWIG_fail;
23745 swig_obj[0] = args;
23746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23747 if (!SWIG_IsOK(res1)) {
23748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23749 }
23750 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23751 result = (unsigned int) ((arg1)->m_rawCode);
23752 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23760 PyObject *resultobj = 0;
23761 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23762 unsigned int arg2 ;
23763 void *argp1 = 0 ;
23764 int res1 = 0 ;
23765 unsigned int val2 ;
23766 int ecode2 = 0 ;
23767 PyObject *swig_obj[2] ;
23768
23769 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23771 if (!SWIG_IsOK(res1)) {
23772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23773 }
23774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23775 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23776 if (!SWIG_IsOK(ecode2)) {
23777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23778 }
23779 arg2 = static_cast< unsigned int >(val2);
23780 if (arg1) (arg1)->m_rawFlags = arg2;
23781
23782 resultobj = SWIG_Py_Void();
23783 return resultobj;
23784 fail:
23785 return NULL;
23786 }
23787
23788
23789 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23790 PyObject *resultobj = 0;
23791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23792 unsigned int result;
23793 void *argp1 = 0 ;
23794 int res1 = 0 ;
23795 PyObject *swig_obj[1] ;
23796
23797 if (!args) SWIG_fail;
23798 swig_obj[0] = args;
23799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23800 if (!SWIG_IsOK(res1)) {
23801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23802 }
23803 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23804 result = (unsigned int) ((arg1)->m_rawFlags);
23805 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23813 PyObject *obj;
23814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23815 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23816 return SWIG_Py_Void();
23817 }
23818
23819 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23820 return SWIG_Python_InitShadowInstance(args);
23821 }
23822
23823 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23824 PyObject *resultobj = 0;
23825 wxSize const &arg1_defvalue = wxDefaultSize ;
23826 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23827 int arg2 = (int) 0 ;
23828 wxSizeEvent *result = 0 ;
23829 wxSize temp1 ;
23830 int val2 ;
23831 int ecode2 = 0 ;
23832 PyObject * obj0 = 0 ;
23833 PyObject * obj1 = 0 ;
23834 char * kwnames[] = {
23835 (char *) "sz",(char *) "winid", NULL
23836 };
23837
23838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23839 if (obj0) {
23840 {
23841 arg1 = &temp1;
23842 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23843 }
23844 }
23845 if (obj1) {
23846 ecode2 = SWIG_AsVal_int(obj1, &val2);
23847 if (!SWIG_IsOK(ecode2)) {
23848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23849 }
23850 arg2 = static_cast< int >(val2);
23851 }
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23868 wxSize result;
23869 void *argp1 = 0 ;
23870 int res1 = 0 ;
23871 PyObject *swig_obj[1] ;
23872
23873 if (!args) SWIG_fail;
23874 swig_obj[0] = args;
23875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23878 }
23879 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = ((wxSizeEvent const *)arg1)->GetSize();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23894 PyObject *resultobj = 0;
23895 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23896 wxRect result;
23897 void *argp1 = 0 ;
23898 int res1 = 0 ;
23899 PyObject *swig_obj[1] ;
23900
23901 if (!args) SWIG_fail;
23902 swig_obj[0] = args;
23903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23904 if (!SWIG_IsOK(res1)) {
23905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23906 }
23907 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = ((wxSizeEvent const *)arg1)->GetRect();
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23922 PyObject *resultobj = 0;
23923 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23924 wxRect arg2 ;
23925 void *argp1 = 0 ;
23926 int res1 = 0 ;
23927 void *argp2 ;
23928 int res2 = 0 ;
23929 PyObject * obj0 = 0 ;
23930 PyObject * obj1 = 0 ;
23931 char * kwnames[] = {
23932 (char *) "self",(char *) "rect", NULL
23933 };
23934
23935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23937 if (!SWIG_IsOK(res1)) {
23938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23939 }
23940 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23941 {
23942 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23943 if (!SWIG_IsOK(res2)) {
23944 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23945 }
23946 if (!argp2) {
23947 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23948 } else {
23949 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23950 arg2 = *temp;
23951 if (SWIG_IsNewObj(res2)) delete temp;
23952 }
23953 }
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 (arg1)->SetRect(arg2);
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 resultobj = SWIG_Py_Void();
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = 0;
23969 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23970 wxSize arg2 ;
23971 void *argp1 = 0 ;
23972 int res1 = 0 ;
23973 void *argp2 ;
23974 int res2 = 0 ;
23975 PyObject * obj0 = 0 ;
23976 PyObject * obj1 = 0 ;
23977 char * kwnames[] = {
23978 (char *) "self",(char *) "size", NULL
23979 };
23980
23981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23985 }
23986 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23987 {
23988 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23989 if (!SWIG_IsOK(res2)) {
23990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23991 }
23992 if (!argp2) {
23993 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23994 } else {
23995 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23996 arg2 = *temp;
23997 if (SWIG_IsNewObj(res2)) delete temp;
23998 }
23999 }
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 wxSizeEvent_SetSize(arg1,arg2);
24003 wxPyEndAllowThreads(__tstate);
24004 if (PyErr_Occurred()) SWIG_fail;
24005 }
24006 resultobj = SWIG_Py_Void();
24007 return resultobj;
24008 fail:
24009 return NULL;
24010 }
24011
24012
24013 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 PyObject *resultobj = 0;
24015 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24016 wxSize *arg2 = (wxSize *) 0 ;
24017 void *argp1 = 0 ;
24018 int res1 = 0 ;
24019 void *argp2 = 0 ;
24020 int res2 = 0 ;
24021 PyObject *swig_obj[2] ;
24022
24023 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
24024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24025 if (!SWIG_IsOK(res1)) {
24026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24027 }
24028 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24029 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
24030 if (!SWIG_IsOK(res2)) {
24031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
24032 }
24033 arg2 = reinterpret_cast< wxSize * >(argp2);
24034 if (arg1) (arg1)->m_size = *arg2;
24035
24036 resultobj = SWIG_Py_Void();
24037 return resultobj;
24038 fail:
24039 return NULL;
24040 }
24041
24042
24043 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24044 PyObject *resultobj = 0;
24045 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24046 wxSize *result = 0 ;
24047 void *argp1 = 0 ;
24048 int res1 = 0 ;
24049 PyObject *swig_obj[1] ;
24050
24051 if (!args) SWIG_fail;
24052 swig_obj[0] = args;
24053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24054 if (!SWIG_IsOK(res1)) {
24055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24056 }
24057 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24058 result = (wxSize *)& ((arg1)->m_size);
24059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
24060 return resultobj;
24061 fail:
24062 return NULL;
24063 }
24064
24065
24066 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24067 PyObject *resultobj = 0;
24068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24069 wxRect *arg2 = (wxRect *) 0 ;
24070 void *argp1 = 0 ;
24071 int res1 = 0 ;
24072 void *argp2 = 0 ;
24073 int res2 = 0 ;
24074 PyObject *swig_obj[2] ;
24075
24076 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
24077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24080 }
24081 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24082 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
24083 if (!SWIG_IsOK(res2)) {
24084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
24085 }
24086 arg2 = reinterpret_cast< wxRect * >(argp2);
24087 if (arg1) (arg1)->m_rect = *arg2;
24088
24089 resultobj = SWIG_Py_Void();
24090 return resultobj;
24091 fail:
24092 return NULL;
24093 }
24094
24095
24096 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24097 PyObject *resultobj = 0;
24098 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
24099 wxRect *result = 0 ;
24100 void *argp1 = 0 ;
24101 int res1 = 0 ;
24102 PyObject *swig_obj[1] ;
24103
24104 if (!args) SWIG_fail;
24105 swig_obj[0] = args;
24106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
24107 if (!SWIG_IsOK(res1)) {
24108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
24109 }
24110 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
24111 result = (wxRect *)& ((arg1)->m_rect);
24112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
24113 return resultobj;
24114 fail:
24115 return NULL;
24116 }
24117
24118
24119 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24120 PyObject *obj;
24121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24122 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
24123 return SWIG_Py_Void();
24124 }
24125
24126 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24127 return SWIG_Python_InitShadowInstance(args);
24128 }
24129
24130 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24131 PyObject *resultobj = 0;
24132 wxPoint const &arg1_defvalue = wxDefaultPosition ;
24133 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
24134 int arg2 = (int) 0 ;
24135 wxMoveEvent *result = 0 ;
24136 wxPoint temp1 ;
24137 int val2 ;
24138 int ecode2 = 0 ;
24139 PyObject * obj0 = 0 ;
24140 PyObject * obj1 = 0 ;
24141 char * kwnames[] = {
24142 (char *) "pos",(char *) "winid", NULL
24143 };
24144
24145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24146 if (obj0) {
24147 {
24148 arg1 = &temp1;
24149 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
24150 }
24151 }
24152 if (obj1) {
24153 ecode2 = SWIG_AsVal_int(obj1, &val2);
24154 if (!SWIG_IsOK(ecode2)) {
24155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
24156 }
24157 arg2 = static_cast< int >(val2);
24158 }
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *resultobj = 0;
24174 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24175 wxPoint result;
24176 void *argp1 = 0 ;
24177 int res1 = 0 ;
24178 PyObject *swig_obj[1] ;
24179
24180 if (!args) SWIG_fail;
24181 swig_obj[0] = args;
24182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24183 if (!SWIG_IsOK(res1)) {
24184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24185 }
24186 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 result = ((wxMoveEvent const *)arg1)->GetPosition();
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *resultobj = 0;
24202 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24203 wxRect result;
24204 void *argp1 = 0 ;
24205 int res1 = 0 ;
24206 PyObject *swig_obj[1] ;
24207
24208 if (!args) SWIG_fail;
24209 swig_obj[0] = args;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24215 {
24216 PyThreadState* __tstate = wxPyBeginAllowThreads();
24217 result = ((wxMoveEvent const *)arg1)->GetRect();
24218 wxPyEndAllowThreads(__tstate);
24219 if (PyErr_Occurred()) SWIG_fail;
24220 }
24221 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24231 wxRect *arg2 = 0 ;
24232 void *argp1 = 0 ;
24233 int res1 = 0 ;
24234 wxRect temp2 ;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char * kwnames[] = {
24238 (char *) "self",(char *) "rect", NULL
24239 };
24240
24241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
24242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24243 if (!SWIG_IsOK(res1)) {
24244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24245 }
24246 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24247 {
24248 arg2 = &temp2;
24249 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
24250 }
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetRect((wxRect const &)*arg2);
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_Py_Void();
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24265 PyObject *resultobj = 0;
24266 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
24267 wxPoint *arg2 = 0 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 wxPoint temp2 ;
24271 PyObject * obj0 = 0 ;
24272 PyObject * obj1 = 0 ;
24273 char * kwnames[] = {
24274 (char *) "self",(char *) "pos", NULL
24275 };
24276
24277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
24279 if (!SWIG_IsOK(res1)) {
24280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
24281 }
24282 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
24283 {
24284 arg2 = &temp2;
24285 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
24286 }
24287 {
24288 PyThreadState* __tstate = wxPyBeginAllowThreads();
24289 (arg1)->SetPosition((wxPoint const &)*arg2);
24290 wxPyEndAllowThreads(__tstate);
24291 if (PyErr_Occurred()) SWIG_fail;
24292 }
24293 resultobj = SWIG_Py_Void();
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24301 PyObject *obj;
24302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24303 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
24304 return SWIG_Py_Void();
24305 }
24306
24307 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24308 return SWIG_Python_InitShadowInstance(args);
24309 }
24310
24311 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj = 0;
24313 int arg1 = (int) 0 ;
24314 wxPaintEvent *result = 0 ;
24315 int val1 ;
24316 int ecode1 = 0 ;
24317 PyObject * obj0 = 0 ;
24318 char * kwnames[] = {
24319 (char *) "Id", NULL
24320 };
24321
24322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
24323 if (obj0) {
24324 ecode1 = SWIG_AsVal_int(obj0, &val1);
24325 if (!SWIG_IsOK(ecode1)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
24327 }
24328 arg1 = static_cast< int >(val1);
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = (wxPaintEvent *)new wxPaintEvent(arg1);
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24344 PyObject *obj;
24345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24346 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
24347 return SWIG_Py_Void();
24348 }
24349
24350 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24351 return SWIG_Python_InitShadowInstance(args);
24352 }
24353
24354 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = 0;
24356 int arg1 = (int) 0 ;
24357 wxNcPaintEvent *result = 0 ;
24358 int val1 ;
24359 int ecode1 = 0 ;
24360 PyObject * obj0 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "winid", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
24366 if (obj0) {
24367 ecode1 = SWIG_AsVal_int(obj0, &val1);
24368 if (!SWIG_IsOK(ecode1)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
24370 }
24371 arg1 = static_cast< int >(val1);
24372 }
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
24376 wxPyEndAllowThreads(__tstate);
24377 if (PyErr_Occurred()) SWIG_fail;
24378 }
24379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
24380 return resultobj;
24381 fail:
24382 return NULL;
24383 }
24384
24385
24386 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24387 PyObject *obj;
24388 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24389 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
24390 return SWIG_Py_Void();
24391 }
24392
24393 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 return SWIG_Python_InitShadowInstance(args);
24395 }
24396
24397 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24398 PyObject *resultobj = 0;
24399 int arg1 = (int) 0 ;
24400 wxDC *arg2 = (wxDC *) NULL ;
24401 wxEraseEvent *result = 0 ;
24402 int val1 ;
24403 int ecode1 = 0 ;
24404 void *argp2 = 0 ;
24405 int res2 = 0 ;
24406 PyObject * obj0 = 0 ;
24407 PyObject * obj1 = 0 ;
24408 char * kwnames[] = {
24409 (char *) "Id",(char *) "dc", NULL
24410 };
24411
24412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24413 if (obj0) {
24414 ecode1 = SWIG_AsVal_int(obj0, &val1);
24415 if (!SWIG_IsOK(ecode1)) {
24416 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
24417 }
24418 arg1 = static_cast< int >(val1);
24419 }
24420 if (obj1) {
24421 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
24422 if (!SWIG_IsOK(res2)) {
24423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
24424 }
24425 arg2 = reinterpret_cast< wxDC * >(argp2);
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24441 PyObject *resultobj = 0;
24442 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
24443 wxDC *result = 0 ;
24444 void *argp1 = 0 ;
24445 int res1 = 0 ;
24446 PyObject *swig_obj[1] ;
24447
24448 if (!args) SWIG_fail;
24449 swig_obj[0] = args;
24450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
24451 if (!SWIG_IsOK(res1)) {
24452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
24453 }
24454 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
24455 {
24456 PyThreadState* __tstate = wxPyBeginAllowThreads();
24457 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
24458 wxPyEndAllowThreads(__tstate);
24459 if (PyErr_Occurred()) SWIG_fail;
24460 }
24461 {
24462 resultobj = wxPyMake_wxObject(result, (bool)0);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24471 PyObject *obj;
24472 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24473 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24474 return SWIG_Py_Void();
24475 }
24476
24477 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24478 return SWIG_Python_InitShadowInstance(args);
24479 }
24480
24481 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj = 0;
24483 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24484 int arg2 = (int) 0 ;
24485 wxFocusEvent *result = 0 ;
24486 int val1 ;
24487 int ecode1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject * obj0 = 0 ;
24491 PyObject * obj1 = 0 ;
24492 char * kwnames[] = {
24493 (char *) "type",(char *) "winid", NULL
24494 };
24495
24496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24497 if (obj0) {
24498 ecode1 = SWIG_AsVal_int(obj0, &val1);
24499 if (!SWIG_IsOK(ecode1)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24501 }
24502 arg1 = static_cast< wxEventType >(val1);
24503 }
24504 if (obj1) {
24505 ecode2 = SWIG_AsVal_int(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24508 }
24509 arg2 = static_cast< int >(val2);
24510 }
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24527 wxWindow *result = 0 ;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = wxPyMake_wxObject(result, (bool)0);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24555 PyObject *resultobj = 0;
24556 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24557 wxWindow *arg2 = (wxWindow *) 0 ;
24558 void *argp1 = 0 ;
24559 int res1 = 0 ;
24560 void *argp2 = 0 ;
24561 int res2 = 0 ;
24562 PyObject * obj0 = 0 ;
24563 PyObject * obj1 = 0 ;
24564 char * kwnames[] = {
24565 (char *) "self",(char *) "win", NULL
24566 };
24567
24568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24572 }
24573 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24575 if (!SWIG_IsOK(res2)) {
24576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24577 }
24578 arg2 = reinterpret_cast< wxWindow * >(argp2);
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 (arg1)->SetWindow(arg2);
24582 wxPyEndAllowThreads(__tstate);
24583 if (PyErr_Occurred()) SWIG_fail;
24584 }
24585 resultobj = SWIG_Py_Void();
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24593 PyObject *obj;
24594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24595 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24596 return SWIG_Py_Void();
24597 }
24598
24599 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24600 return SWIG_Python_InitShadowInstance(args);
24601 }
24602
24603 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = 0;
24605 wxWindow *arg1 = (wxWindow *) NULL ;
24606 wxChildFocusEvent *result = 0 ;
24607 void *argp1 = 0 ;
24608 int res1 = 0 ;
24609 PyObject * obj0 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "win", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24615 if (obj0) {
24616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24617 if (!SWIG_IsOK(res1)) {
24618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24619 }
24620 arg1 = reinterpret_cast< wxWindow * >(argp1);
24621 }
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24625 wxPyEndAllowThreads(__tstate);
24626 if (PyErr_Occurred()) SWIG_fail;
24627 }
24628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24629 return resultobj;
24630 fail:
24631 return NULL;
24632 }
24633
24634
24635 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24636 PyObject *resultobj = 0;
24637 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24638 wxWindow *result = 0 ;
24639 void *argp1 = 0 ;
24640 int res1 = 0 ;
24641 PyObject *swig_obj[1] ;
24642
24643 if (!args) SWIG_fail;
24644 swig_obj[0] = args;
24645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24648 }
24649 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24650 {
24651 PyThreadState* __tstate = wxPyBeginAllowThreads();
24652 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24653 wxPyEndAllowThreads(__tstate);
24654 if (PyErr_Occurred()) SWIG_fail;
24655 }
24656 {
24657 resultobj = wxPyMake_wxObject(result, (bool)0);
24658 }
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *obj;
24667 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24668 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24669 return SWIG_Py_Void();
24670 }
24671
24672 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 return SWIG_Python_InitShadowInstance(args);
24674 }
24675
24676 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj = 0;
24678 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24679 bool arg2 = (bool) true ;
24680 int arg3 = (int) 0 ;
24681 wxActivateEvent *result = 0 ;
24682 int val1 ;
24683 int ecode1 = 0 ;
24684 bool val2 ;
24685 int ecode2 = 0 ;
24686 int val3 ;
24687 int ecode3 = 0 ;
24688 PyObject * obj0 = 0 ;
24689 PyObject * obj1 = 0 ;
24690 PyObject * obj2 = 0 ;
24691 char * kwnames[] = {
24692 (char *) "type",(char *) "active",(char *) "Id", NULL
24693 };
24694
24695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24696 if (obj0) {
24697 ecode1 = SWIG_AsVal_int(obj0, &val1);
24698 if (!SWIG_IsOK(ecode1)) {
24699 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24700 }
24701 arg1 = static_cast< wxEventType >(val1);
24702 }
24703 if (obj1) {
24704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24705 if (!SWIG_IsOK(ecode2)) {
24706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24707 }
24708 arg2 = static_cast< bool >(val2);
24709 }
24710 if (obj2) {
24711 ecode3 = SWIG_AsVal_int(obj2, &val3);
24712 if (!SWIG_IsOK(ecode3)) {
24713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24714 }
24715 arg3 = static_cast< int >(val3);
24716 }
24717 {
24718 PyThreadState* __tstate = wxPyBeginAllowThreads();
24719 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24724 return resultobj;
24725 fail:
24726 return NULL;
24727 }
24728
24729
24730 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24731 PyObject *resultobj = 0;
24732 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24733 bool result;
24734 void *argp1 = 0 ;
24735 int res1 = 0 ;
24736 PyObject *swig_obj[1] ;
24737
24738 if (!args) SWIG_fail;
24739 swig_obj[0] = args;
24740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24741 if (!SWIG_IsOK(res1)) {
24742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24743 }
24744 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24745 {
24746 PyThreadState* __tstate = wxPyBeginAllowThreads();
24747 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 {
24752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24761 PyObject *obj;
24762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24763 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24764 return SWIG_Py_Void();
24765 }
24766
24767 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24768 return SWIG_Python_InitShadowInstance(args);
24769 }
24770
24771 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24772 PyObject *resultobj = 0;
24773 int arg1 = (int) 0 ;
24774 wxInitDialogEvent *result = 0 ;
24775 int val1 ;
24776 int ecode1 = 0 ;
24777 PyObject * obj0 = 0 ;
24778 char * kwnames[] = {
24779 (char *) "Id", NULL
24780 };
24781
24782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24783 if (obj0) {
24784 ecode1 = SWIG_AsVal_int(obj0, &val1);
24785 if (!SWIG_IsOK(ecode1)) {
24786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24787 }
24788 arg1 = static_cast< int >(val1);
24789 }
24790 {
24791 PyThreadState* __tstate = wxPyBeginAllowThreads();
24792 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24793 wxPyEndAllowThreads(__tstate);
24794 if (PyErr_Occurred()) SWIG_fail;
24795 }
24796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24817 int arg2 = (int) 0 ;
24818 wxMenu *arg3 = (wxMenu *) NULL ;
24819 wxMenuEvent *result = 0 ;
24820 int val1 ;
24821 int ecode1 = 0 ;
24822 int val2 ;
24823 int ecode2 = 0 ;
24824 void *argp3 = 0 ;
24825 int res3 = 0 ;
24826 PyObject * obj0 = 0 ;
24827 PyObject * obj1 = 0 ;
24828 PyObject * obj2 = 0 ;
24829 char * kwnames[] = {
24830 (char *) "type",(char *) "winid",(char *) "menu", NULL
24831 };
24832
24833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24834 if (obj0) {
24835 ecode1 = SWIG_AsVal_int(obj0, &val1);
24836 if (!SWIG_IsOK(ecode1)) {
24837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24838 }
24839 arg1 = static_cast< wxEventType >(val1);
24840 }
24841 if (obj1) {
24842 ecode2 = SWIG_AsVal_int(obj1, &val2);
24843 if (!SWIG_IsOK(ecode2)) {
24844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24845 }
24846 arg2 = static_cast< int >(val2);
24847 }
24848 if (obj2) {
24849 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24850 if (!SWIG_IsOK(res3)) {
24851 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24852 }
24853 arg3 = reinterpret_cast< wxMenu * >(argp3);
24854 }
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24858 wxPyEndAllowThreads(__tstate);
24859 if (PyErr_Occurred()) SWIG_fail;
24860 }
24861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24862 return resultobj;
24863 fail:
24864 return NULL;
24865 }
24866
24867
24868 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24869 PyObject *resultobj = 0;
24870 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24871 int result;
24872 void *argp1 = 0 ;
24873 int res1 = 0 ;
24874 PyObject *swig_obj[1] ;
24875
24876 if (!args) SWIG_fail;
24877 swig_obj[0] = args;
24878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24879 if (!SWIG_IsOK(res1)) {
24880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24881 }
24882 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24883 {
24884 PyThreadState* __tstate = wxPyBeginAllowThreads();
24885 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24886 wxPyEndAllowThreads(__tstate);
24887 if (PyErr_Occurred()) SWIG_fail;
24888 }
24889 resultobj = SWIG_From_int(static_cast< int >(result));
24890 return resultobj;
24891 fail:
24892 return NULL;
24893 }
24894
24895
24896 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24897 PyObject *resultobj = 0;
24898 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24899 bool result;
24900 void *argp1 = 0 ;
24901 int res1 = 0 ;
24902 PyObject *swig_obj[1] ;
24903
24904 if (!args) SWIG_fail;
24905 swig_obj[0] = args;
24906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24907 if (!SWIG_IsOK(res1)) {
24908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24909 }
24910 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 {
24918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24919 }
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24927 PyObject *resultobj = 0;
24928 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24929 wxMenu *result = 0 ;
24930 void *argp1 = 0 ;
24931 int res1 = 0 ;
24932 PyObject *swig_obj[1] ;
24933
24934 if (!args) SWIG_fail;
24935 swig_obj[0] = args;
24936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24937 if (!SWIG_IsOK(res1)) {
24938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24939 }
24940 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24941 {
24942 PyThreadState* __tstate = wxPyBeginAllowThreads();
24943 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 {
24948 resultobj = wxPyMake_wxObject(result, (bool)0);
24949 }
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24957 PyObject *obj;
24958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24959 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24960 return SWIG_Py_Void();
24961 }
24962
24963 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24964 return SWIG_Python_InitShadowInstance(args);
24965 }
24966
24967 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24968 PyObject *resultobj = 0;
24969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24970 int arg2 = (int) 0 ;
24971 wxCloseEvent *result = 0 ;
24972 int val1 ;
24973 int ecode1 = 0 ;
24974 int val2 ;
24975 int ecode2 = 0 ;
24976 PyObject * obj0 = 0 ;
24977 PyObject * obj1 = 0 ;
24978 char * kwnames[] = {
24979 (char *) "type",(char *) "winid", NULL
24980 };
24981
24982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24983 if (obj0) {
24984 ecode1 = SWIG_AsVal_int(obj0, &val1);
24985 if (!SWIG_IsOK(ecode1)) {
24986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24987 }
24988 arg1 = static_cast< wxEventType >(val1);
24989 }
24990 if (obj1) {
24991 ecode2 = SWIG_AsVal_int(obj1, &val2);
24992 if (!SWIG_IsOK(ecode2)) {
24993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24994 }
24995 arg2 = static_cast< int >(val2);
24996 }
24997 {
24998 PyThreadState* __tstate = wxPyBeginAllowThreads();
24999 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = 0;
25012 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25013 bool arg2 ;
25014 void *argp1 = 0 ;
25015 int res1 = 0 ;
25016 bool val2 ;
25017 int ecode2 = 0 ;
25018 PyObject * obj0 = 0 ;
25019 PyObject * obj1 = 0 ;
25020 char * kwnames[] = {
25021 (char *) "self",(char *) "logOff", NULL
25022 };
25023
25024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
25025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25026 if (!SWIG_IsOK(res1)) {
25027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25028 }
25029 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25031 if (!SWIG_IsOK(ecode2)) {
25032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
25033 }
25034 arg2 = static_cast< bool >(val2);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 (arg1)->SetLoggingOff(arg2);
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 resultobj = SWIG_Py_Void();
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25049 PyObject *resultobj = 0;
25050 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25051 bool result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject *swig_obj[1] ;
25055
25056 if (!args) SWIG_fail;
25057 swig_obj[0] = args;
25058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj = 0;
25080 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25081 bool arg2 = (bool) true ;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 bool val2 ;
25085 int ecode2 = 0 ;
25086 PyObject * obj0 = 0 ;
25087 PyObject * obj1 = 0 ;
25088 char * kwnames[] = {
25089 (char *) "self",(char *) "veto", NULL
25090 };
25091
25092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
25093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25094 if (!SWIG_IsOK(res1)) {
25095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25096 }
25097 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25098 if (obj1) {
25099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25100 if (!SWIG_IsOK(ecode2)) {
25101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
25102 }
25103 arg2 = static_cast< bool >(val2);
25104 }
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 (arg1)->Veto(arg2);
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 resultobj = SWIG_Py_Void();
25112 return resultobj;
25113 fail:
25114 return NULL;
25115 }
25116
25117
25118 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25119 PyObject *resultobj = 0;
25120 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25121 bool result;
25122 void *argp1 = 0 ;
25123 int res1 = 0 ;
25124 PyObject *swig_obj[1] ;
25125
25126 if (!args) SWIG_fail;
25127 swig_obj[0] = args;
25128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25129 if (!SWIG_IsOK(res1)) {
25130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25131 }
25132 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25133 {
25134 PyThreadState* __tstate = wxPyBeginAllowThreads();
25135 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
25136 wxPyEndAllowThreads(__tstate);
25137 if (PyErr_Occurred()) SWIG_fail;
25138 }
25139 {
25140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25141 }
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj = 0;
25150 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25151 bool arg2 ;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 bool val2 ;
25155 int ecode2 = 0 ;
25156 PyObject * obj0 = 0 ;
25157 PyObject * obj1 = 0 ;
25158 char * kwnames[] = {
25159 (char *) "self",(char *) "canVeto", NULL
25160 };
25161
25162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
25163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
25166 }
25167 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25168 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25169 if (!SWIG_IsOK(ecode2)) {
25170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
25171 }
25172 arg2 = static_cast< bool >(val2);
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 (arg1)->SetCanVeto(arg2);
25176 wxPyEndAllowThreads(__tstate);
25177 if (PyErr_Occurred()) SWIG_fail;
25178 }
25179 resultobj = SWIG_Py_Void();
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25187 PyObject *resultobj = 0;
25188 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
25189 bool result;
25190 void *argp1 = 0 ;
25191 int res1 = 0 ;
25192 PyObject *swig_obj[1] ;
25193
25194 if (!args) SWIG_fail;
25195 swig_obj[0] = args;
25196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
25197 if (!SWIG_IsOK(res1)) {
25198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
25199 }
25200 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
25201 {
25202 PyThreadState* __tstate = wxPyBeginAllowThreads();
25203 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
25204 wxPyEndAllowThreads(__tstate);
25205 if (PyErr_Occurred()) SWIG_fail;
25206 }
25207 {
25208 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25209 }
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25217 PyObject *obj;
25218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25219 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
25220 return SWIG_Py_Void();
25221 }
25222
25223 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25224 return SWIG_Python_InitShadowInstance(args);
25225 }
25226
25227 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25228 PyObject *resultobj = 0;
25229 int arg1 = (int) 0 ;
25230 bool arg2 = (bool) false ;
25231 wxShowEvent *result = 0 ;
25232 int val1 ;
25233 int ecode1 = 0 ;
25234 bool val2 ;
25235 int ecode2 = 0 ;
25236 PyObject * obj0 = 0 ;
25237 PyObject * obj1 = 0 ;
25238 char * kwnames[] = {
25239 (char *) "winid",(char *) "show", NULL
25240 };
25241
25242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25243 if (obj0) {
25244 ecode1 = SWIG_AsVal_int(obj0, &val1);
25245 if (!SWIG_IsOK(ecode1)) {
25246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
25247 }
25248 arg1 = static_cast< int >(val1);
25249 }
25250 if (obj1) {
25251 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25252 if (!SWIG_IsOK(ecode2)) {
25253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
25254 }
25255 arg2 = static_cast< bool >(val2);
25256 }
25257 {
25258 PyThreadState* __tstate = wxPyBeginAllowThreads();
25259 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
25260 wxPyEndAllowThreads(__tstate);
25261 if (PyErr_Occurred()) SWIG_fail;
25262 }
25263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
25264 return resultobj;
25265 fail:
25266 return NULL;
25267 }
25268
25269
25270 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25271 PyObject *resultobj = 0;
25272 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25273 bool arg2 ;
25274 void *argp1 = 0 ;
25275 int res1 = 0 ;
25276 bool val2 ;
25277 int ecode2 = 0 ;
25278 PyObject * obj0 = 0 ;
25279 PyObject * obj1 = 0 ;
25280 char * kwnames[] = {
25281 (char *) "self",(char *) "show", NULL
25282 };
25283
25284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
25285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25286 if (!SWIG_IsOK(res1)) {
25287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
25288 }
25289 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25291 if (!SWIG_IsOK(ecode2)) {
25292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
25293 }
25294 arg2 = static_cast< bool >(val2);
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 (arg1)->SetShow(arg2);
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 resultobj = SWIG_Py_Void();
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25309 PyObject *resultobj = 0;
25310 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
25311 bool result;
25312 void *argp1 = 0 ;
25313 int res1 = 0 ;
25314 PyObject *swig_obj[1] ;
25315
25316 if (!args) SWIG_fail;
25317 swig_obj[0] = args;
25318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
25319 if (!SWIG_IsOK(res1)) {
25320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
25321 }
25322 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
25323 {
25324 PyThreadState* __tstate = wxPyBeginAllowThreads();
25325 result = (bool)((wxShowEvent const *)arg1)->GetShow();
25326 wxPyEndAllowThreads(__tstate);
25327 if (PyErr_Occurred()) SWIG_fail;
25328 }
25329 {
25330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25331 }
25332 return resultobj;
25333 fail:
25334 return NULL;
25335 }
25336
25337
25338 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25339 PyObject *obj;
25340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25341 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
25342 return SWIG_Py_Void();
25343 }
25344
25345 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25346 return SWIG_Python_InitShadowInstance(args);
25347 }
25348
25349 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 int arg1 = (int) 0 ;
25352 bool arg2 = (bool) true ;
25353 wxIconizeEvent *result = 0 ;
25354 int val1 ;
25355 int ecode1 = 0 ;
25356 bool val2 ;
25357 int ecode2 = 0 ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "id",(char *) "iconized", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25365 if (obj0) {
25366 ecode1 = SWIG_AsVal_int(obj0, &val1);
25367 if (!SWIG_IsOK(ecode1)) {
25368 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
25369 }
25370 arg1 = static_cast< int >(val1);
25371 }
25372 if (obj1) {
25373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25374 if (!SWIG_IsOK(ecode2)) {
25375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
25376 }
25377 arg2 = static_cast< bool >(val2);
25378 }
25379 {
25380 PyThreadState* __tstate = wxPyBeginAllowThreads();
25381 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
25382 wxPyEndAllowThreads(__tstate);
25383 if (PyErr_Occurred()) SWIG_fail;
25384 }
25385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25393 PyObject *resultobj = 0;
25394 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
25395 bool result;
25396 void *argp1 = 0 ;
25397 int res1 = 0 ;
25398 PyObject *swig_obj[1] ;
25399
25400 if (!args) SWIG_fail;
25401 swig_obj[0] = args;
25402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
25403 if (!SWIG_IsOK(res1)) {
25404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
25405 }
25406 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
25407 {
25408 PyThreadState* __tstate = wxPyBeginAllowThreads();
25409 result = (bool)(arg1)->Iconized();
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25415 }
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25423 PyObject *obj;
25424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25425 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
25426 return SWIG_Py_Void();
25427 }
25428
25429 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 return SWIG_Python_InitShadowInstance(args);
25431 }
25432
25433 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj = 0;
25435 int arg1 = (int) 0 ;
25436 wxMaximizeEvent *result = 0 ;
25437 int val1 ;
25438 int ecode1 = 0 ;
25439 PyObject * obj0 = 0 ;
25440 char * kwnames[] = {
25441 (char *) "id", NULL
25442 };
25443
25444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
25445 if (obj0) {
25446 ecode1 = SWIG_AsVal_int(obj0, &val1);
25447 if (!SWIG_IsOK(ecode1)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
25449 }
25450 arg1 = static_cast< int >(val1);
25451 }
25452 {
25453 PyThreadState* __tstate = wxPyBeginAllowThreads();
25454 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
25455 wxPyEndAllowThreads(__tstate);
25456 if (PyErr_Occurred()) SWIG_fail;
25457 }
25458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25479 wxPoint result;
25480 void *argp1 = 0 ;
25481 int res1 = 0 ;
25482 PyObject *swig_obj[1] ;
25483
25484 if (!args) SWIG_fail;
25485 swig_obj[0] = args;
25486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25487 if (!SWIG_IsOK(res1)) {
25488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25489 }
25490 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 result = (arg1)->GetPosition();
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25505 PyObject *resultobj = 0;
25506 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25507 int result;
25508 void *argp1 = 0 ;
25509 int res1 = 0 ;
25510 PyObject *swig_obj[1] ;
25511
25512 if (!args) SWIG_fail;
25513 swig_obj[0] = args;
25514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25515 if (!SWIG_IsOK(res1)) {
25516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25517 }
25518 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25519 {
25520 PyThreadState* __tstate = wxPyBeginAllowThreads();
25521 result = (int)(arg1)->GetNumberOfFiles();
25522 wxPyEndAllowThreads(__tstate);
25523 if (PyErr_Occurred()) SWIG_fail;
25524 }
25525 resultobj = SWIG_From_int(static_cast< int >(result));
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25533 PyObject *resultobj = 0;
25534 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25535 PyObject *result = 0 ;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 PyObject *swig_obj[1] ;
25539
25540 if (!args) SWIG_fail;
25541 swig_obj[0] = args;
25542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25545 }
25546 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25547 {
25548 PyThreadState* __tstate = wxPyBeginAllowThreads();
25549 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 resultobj = result;
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25561 PyObject *obj;
25562 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25563 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25564 return SWIG_Py_Void();
25565 }
25566
25567 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25568 PyObject *resultobj = 0;
25569 int arg1 = (int) 0 ;
25570 wxUpdateUIEvent *result = 0 ;
25571 int val1 ;
25572 int ecode1 = 0 ;
25573 PyObject * obj0 = 0 ;
25574 char * kwnames[] = {
25575 (char *) "commandId", NULL
25576 };
25577
25578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25579 if (obj0) {
25580 ecode1 = SWIG_AsVal_int(obj0, &val1);
25581 if (!SWIG_IsOK(ecode1)) {
25582 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25583 }
25584 arg1 = static_cast< int >(val1);
25585 }
25586 {
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25589 wxPyEndAllowThreads(__tstate);
25590 if (PyErr_Occurred()) SWIG_fail;
25591 }
25592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25593 return resultobj;
25594 fail:
25595 return NULL;
25596 }
25597
25598
25599 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25600 PyObject *resultobj = 0;
25601 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25602 bool result;
25603 void *argp1 = 0 ;
25604 int res1 = 0 ;
25605 PyObject *swig_obj[1] ;
25606
25607 if (!args) SWIG_fail;
25608 swig_obj[0] = args;
25609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25610 if (!SWIG_IsOK(res1)) {
25611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25612 }
25613 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 {
25621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25622 }
25623 return resultobj;
25624 fail:
25625 return NULL;
25626 }
25627
25628
25629 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25630 PyObject *resultobj = 0;
25631 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25632 bool result;
25633 void *argp1 = 0 ;
25634 int res1 = 0 ;
25635 PyObject *swig_obj[1] ;
25636
25637 if (!args) SWIG_fail;
25638 swig_obj[0] = args;
25639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25640 if (!SWIG_IsOK(res1)) {
25641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25642 }
25643 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25644 {
25645 PyThreadState* __tstate = wxPyBeginAllowThreads();
25646 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25647 wxPyEndAllowThreads(__tstate);
25648 if (PyErr_Occurred()) SWIG_fail;
25649 }
25650 {
25651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652 }
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25662 bool result;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 PyObject *swig_obj[1] ;
25666
25667 if (!args) SWIG_fail;
25668 swig_obj[0] = args;
25669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25670 if (!SWIG_IsOK(res1)) {
25671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25672 }
25673 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25674 {
25675 PyThreadState* __tstate = wxPyBeginAllowThreads();
25676 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25677 wxPyEndAllowThreads(__tstate);
25678 if (PyErr_Occurred()) SWIG_fail;
25679 }
25680 {
25681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25682 }
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25692 wxString result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 PyObject *swig_obj[1] ;
25696
25697 if (!args) SWIG_fail;
25698 swig_obj[0] = args;
25699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25702 }
25703 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25704 {
25705 PyThreadState* __tstate = wxPyBeginAllowThreads();
25706 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25707 wxPyEndAllowThreads(__tstate);
25708 if (PyErr_Occurred()) SWIG_fail;
25709 }
25710 {
25711 #if wxUSE_UNICODE
25712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25713 #else
25714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25715 #endif
25716 }
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25724 PyObject *resultobj = 0;
25725 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25726 bool result;
25727 void *argp1 = 0 ;
25728 int res1 = 0 ;
25729 PyObject *swig_obj[1] ;
25730
25731 if (!args) SWIG_fail;
25732 swig_obj[0] = args;
25733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25734 if (!SWIG_IsOK(res1)) {
25735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25736 }
25737 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25738 {
25739 PyThreadState* __tstate = wxPyBeginAllowThreads();
25740 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25741 wxPyEndAllowThreads(__tstate);
25742 if (PyErr_Occurred()) SWIG_fail;
25743 }
25744 {
25745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25746 }
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25754 PyObject *resultobj = 0;
25755 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25756 bool result;
25757 void *argp1 = 0 ;
25758 int res1 = 0 ;
25759 PyObject *swig_obj[1] ;
25760
25761 if (!args) SWIG_fail;
25762 swig_obj[0] = args;
25763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25764 if (!SWIG_IsOK(res1)) {
25765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25766 }
25767 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25768 {
25769 PyThreadState* __tstate = wxPyBeginAllowThreads();
25770 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 {
25775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25776 }
25777 return resultobj;
25778 fail:
25779 return NULL;
25780 }
25781
25782
25783 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25784 PyObject *resultobj = 0;
25785 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25786 bool result;
25787 void *argp1 = 0 ;
25788 int res1 = 0 ;
25789 PyObject *swig_obj[1] ;
25790
25791 if (!args) SWIG_fail;
25792 swig_obj[0] = args;
25793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25794 if (!SWIG_IsOK(res1)) {
25795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25796 }
25797 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25798 {
25799 PyThreadState* __tstate = wxPyBeginAllowThreads();
25800 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25801 wxPyEndAllowThreads(__tstate);
25802 if (PyErr_Occurred()) SWIG_fail;
25803 }
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25814 PyObject *resultobj = 0;
25815 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25816 bool result;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 PyObject *swig_obj[1] ;
25820
25821 if (!args) SWIG_fail;
25822 swig_obj[0] = args;
25823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25824 if (!SWIG_IsOK(res1)) {
25825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25826 }
25827 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25831 wxPyEndAllowThreads(__tstate);
25832 if (PyErr_Occurred()) SWIG_fail;
25833 }
25834 {
25835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25836 }
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25844 PyObject *resultobj = 0;
25845 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25846 bool arg2 ;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 bool val2 ;
25850 int ecode2 = 0 ;
25851 PyObject * obj0 = 0 ;
25852 PyObject * obj1 = 0 ;
25853 char * kwnames[] = {
25854 (char *) "self",(char *) "check", NULL
25855 };
25856
25857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25859 if (!SWIG_IsOK(res1)) {
25860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25861 }
25862 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25864 if (!SWIG_IsOK(ecode2)) {
25865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25866 }
25867 arg2 = static_cast< bool >(val2);
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 (arg1)->Check(arg2);
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 resultobj = SWIG_Py_Void();
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj = 0;
25883 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25884 bool arg2 ;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 bool val2 ;
25888 int ecode2 = 0 ;
25889 PyObject * obj0 = 0 ;
25890 PyObject * obj1 = 0 ;
25891 char * kwnames[] = {
25892 (char *) "self",(char *) "enable", NULL
25893 };
25894
25895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25899 }
25900 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25902 if (!SWIG_IsOK(ecode2)) {
25903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25904 }
25905 arg2 = static_cast< bool >(val2);
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->Enable(arg2);
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_Py_Void();
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25920 PyObject *resultobj = 0;
25921 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25922 bool arg2 ;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 bool val2 ;
25926 int ecode2 = 0 ;
25927 PyObject * obj0 = 0 ;
25928 PyObject * obj1 = 0 ;
25929 char * kwnames[] = {
25930 (char *) "self",(char *) "show", NULL
25931 };
25932
25933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25935 if (!SWIG_IsOK(res1)) {
25936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25937 }
25938 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25939 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25940 if (!SWIG_IsOK(ecode2)) {
25941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25942 }
25943 arg2 = static_cast< bool >(val2);
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 (arg1)->Show(arg2);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_Py_Void();
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25958 PyObject *resultobj = 0;
25959 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25960 wxString *arg2 = 0 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 bool temp2 = false ;
25964 PyObject * obj0 = 0 ;
25965 PyObject * obj1 = 0 ;
25966 char * kwnames[] = {
25967 (char *) "self",(char *) "text", NULL
25968 };
25969
25970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25972 if (!SWIG_IsOK(res1)) {
25973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25974 }
25975 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25976 {
25977 arg2 = wxString_in_helper(obj1);
25978 if (arg2 == NULL) SWIG_fail;
25979 temp2 = true;
25980 }
25981 {
25982 PyThreadState* __tstate = wxPyBeginAllowThreads();
25983 (arg1)->SetText((wxString const &)*arg2);
25984 wxPyEndAllowThreads(__tstate);
25985 if (PyErr_Occurred()) SWIG_fail;
25986 }
25987 resultobj = SWIG_Py_Void();
25988 {
25989 if (temp2)
25990 delete arg2;
25991 }
25992 return resultobj;
25993 fail:
25994 {
25995 if (temp2)
25996 delete arg2;
25997 }
25998 return NULL;
25999 }
26000
26001
26002 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 long arg1 ;
26005 long val1 ;
26006 int ecode1 = 0 ;
26007 PyObject * obj0 = 0 ;
26008 char * kwnames[] = {
26009 (char *) "updateInterval", NULL
26010 };
26011
26012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
26013 ecode1 = SWIG_AsVal_long(obj0, &val1);
26014 if (!SWIG_IsOK(ecode1)) {
26015 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
26016 }
26017 arg1 = static_cast< long >(val1);
26018 {
26019 PyThreadState* __tstate = wxPyBeginAllowThreads();
26020 wxUpdateUIEvent::SetUpdateInterval(arg1);
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 resultobj = SWIG_Py_Void();
26025 return resultobj;
26026 fail:
26027 return NULL;
26028 }
26029
26030
26031 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26032 PyObject *resultobj = 0;
26033 long result;
26034
26035 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
26036 {
26037 PyThreadState* __tstate = wxPyBeginAllowThreads();
26038 result = (long)wxUpdateUIEvent::GetUpdateInterval();
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_From_long(static_cast< long >(result));
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj = 0;
26051 wxWindow *arg1 = (wxWindow *) 0 ;
26052 bool result;
26053 void *argp1 = 0 ;
26054 int res1 = 0 ;
26055 PyObject * obj0 = 0 ;
26056 char * kwnames[] = {
26057 (char *) "win", NULL
26058 };
26059
26060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
26061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26062 if (!SWIG_IsOK(res1)) {
26063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
26064 }
26065 arg1 = reinterpret_cast< wxWindow * >(argp1);
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
26069 wxPyEndAllowThreads(__tstate);
26070 if (PyErr_Occurred()) SWIG_fail;
26071 }
26072 {
26073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26074 }
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 PyObject *resultobj = 0;
26083
26084 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 wxUpdateUIEvent::ResetUpdateTime();
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_Py_Void();
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxUpdateUIMode arg1 ;
26101 int val1 ;
26102 int ecode1 = 0 ;
26103 PyObject * obj0 = 0 ;
26104 char * kwnames[] = {
26105 (char *) "mode", NULL
26106 };
26107
26108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26109 ecode1 = SWIG_AsVal_int(obj0, &val1);
26110 if (!SWIG_IsOK(ecode1)) {
26111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
26112 }
26113 arg1 = static_cast< wxUpdateUIMode >(val1);
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 wxUpdateUIEvent::SetMode(arg1);
26117 wxPyEndAllowThreads(__tstate);
26118 if (PyErr_Occurred()) SWIG_fail;
26119 }
26120 resultobj = SWIG_Py_Void();
26121 return resultobj;
26122 fail:
26123 return NULL;
26124 }
26125
26126
26127 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26128 PyObject *resultobj = 0;
26129 wxUpdateUIMode result;
26130
26131 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
26135 wxPyEndAllowThreads(__tstate);
26136 if (PyErr_Occurred()) SWIG_fail;
26137 }
26138 resultobj = SWIG_From_int(static_cast< int >(result));
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *obj;
26147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26148 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
26149 return SWIG_Py_Void();
26150 }
26151
26152 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26153 return SWIG_Python_InitShadowInstance(args);
26154 }
26155
26156 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26157 PyObject *resultobj = 0;
26158 wxSysColourChangedEvent *result = 0 ;
26159
26160 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
26161 {
26162 PyThreadState* __tstate = wxPyBeginAllowThreads();
26163 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
26164 wxPyEndAllowThreads(__tstate);
26165 if (PyErr_Occurred()) SWIG_fail;
26166 }
26167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
26168 return resultobj;
26169 fail:
26170 return NULL;
26171 }
26172
26173
26174 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26175 PyObject *obj;
26176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
26178 return SWIG_Py_Void();
26179 }
26180
26181 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26182 return SWIG_Python_InitShadowInstance(args);
26183 }
26184
26185 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj = 0;
26187 int arg1 = (int) 0 ;
26188 wxWindow *arg2 = (wxWindow *) NULL ;
26189 wxMouseCaptureChangedEvent *result = 0 ;
26190 int val1 ;
26191 int ecode1 = 0 ;
26192 void *argp2 = 0 ;
26193 int res2 = 0 ;
26194 PyObject * obj0 = 0 ;
26195 PyObject * obj1 = 0 ;
26196 char * kwnames[] = {
26197 (char *) "winid",(char *) "gainedCapture", NULL
26198 };
26199
26200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26201 if (obj0) {
26202 ecode1 = SWIG_AsVal_int(obj0, &val1);
26203 if (!SWIG_IsOK(ecode1)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
26205 }
26206 arg1 = static_cast< int >(val1);
26207 }
26208 if (obj1) {
26209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26210 if (!SWIG_IsOK(res2)) {
26211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
26212 }
26213 arg2 = reinterpret_cast< wxWindow * >(argp2);
26214 }
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
26218 wxPyEndAllowThreads(__tstate);
26219 if (PyErr_Occurred()) SWIG_fail;
26220 }
26221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 PyObject *resultobj = 0;
26230 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
26231 wxWindow *result = 0 ;
26232 void *argp1 = 0 ;
26233 int res1 = 0 ;
26234 PyObject *swig_obj[1] ;
26235
26236 if (!args) SWIG_fail;
26237 swig_obj[0] = args;
26238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
26239 if (!SWIG_IsOK(res1)) {
26240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
26241 }
26242 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
26246 wxPyEndAllowThreads(__tstate);
26247 if (PyErr_Occurred()) SWIG_fail;
26248 }
26249 {
26250 resultobj = wxPyMake_wxObject(result, (bool)0);
26251 }
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *obj;
26260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26261 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
26262 return SWIG_Py_Void();
26263 }
26264
26265 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26266 return SWIG_Python_InitShadowInstance(args);
26267 }
26268
26269 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26270 PyObject *resultobj = 0;
26271 int arg1 = (int) 0 ;
26272 wxMouseCaptureLostEvent *result = 0 ;
26273 int val1 ;
26274 int ecode1 = 0 ;
26275 PyObject * obj0 = 0 ;
26276 char * kwnames[] = {
26277 (char *) "winid", NULL
26278 };
26279
26280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
26281 if (obj0) {
26282 ecode1 = SWIG_AsVal_int(obj0, &val1);
26283 if (!SWIG_IsOK(ecode1)) {
26284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
26285 }
26286 arg1 = static_cast< int >(val1);
26287 }
26288 {
26289 PyThreadState* __tstate = wxPyBeginAllowThreads();
26290 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
26291 wxPyEndAllowThreads(__tstate);
26292 if (PyErr_Occurred()) SWIG_fail;
26293 }
26294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *obj;
26303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26304 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
26305 return SWIG_Py_Void();
26306 }
26307
26308 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26309 return SWIG_Python_InitShadowInstance(args);
26310 }
26311
26312 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26313 PyObject *resultobj = 0;
26314 wxDisplayChangedEvent *result = 0 ;
26315
26316 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
26317 {
26318 PyThreadState* __tstate = wxPyBeginAllowThreads();
26319 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26331 PyObject *obj;
26332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26333 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
26334 return SWIG_Py_Void();
26335 }
26336
26337 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26338 return SWIG_Python_InitShadowInstance(args);
26339 }
26340
26341 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 int arg1 = (int) 0 ;
26344 wxPaletteChangedEvent *result = 0 ;
26345 int val1 ;
26346 int ecode1 = 0 ;
26347 PyObject * obj0 = 0 ;
26348 char * kwnames[] = {
26349 (char *) "id", NULL
26350 };
26351
26352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
26353 if (obj0) {
26354 ecode1 = SWIG_AsVal_int(obj0, &val1);
26355 if (!SWIG_IsOK(ecode1)) {
26356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
26357 }
26358 arg1 = static_cast< int >(val1);
26359 }
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26374 PyObject *resultobj = 0;
26375 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26376 wxWindow *arg2 = (wxWindow *) 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 void *argp2 = 0 ;
26380 int res2 = 0 ;
26381 PyObject * obj0 = 0 ;
26382 PyObject * obj1 = 0 ;
26383 char * kwnames[] = {
26384 (char *) "self",(char *) "win", NULL
26385 };
26386
26387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26389 if (!SWIG_IsOK(res1)) {
26390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26391 }
26392 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26394 if (!SWIG_IsOK(res2)) {
26395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26396 }
26397 arg2 = reinterpret_cast< wxWindow * >(argp2);
26398 {
26399 PyThreadState* __tstate = wxPyBeginAllowThreads();
26400 (arg1)->SetChangedWindow(arg2);
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 resultobj = SWIG_Py_Void();
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26412 PyObject *resultobj = 0;
26413 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
26414 wxWindow *result = 0 ;
26415 void *argp1 = 0 ;
26416 int res1 = 0 ;
26417 PyObject *swig_obj[1] ;
26418
26419 if (!args) SWIG_fail;
26420 swig_obj[0] = args;
26421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
26422 if (!SWIG_IsOK(res1)) {
26423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
26424 }
26425 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
26426 {
26427 PyThreadState* __tstate = wxPyBeginAllowThreads();
26428 result = (wxWindow *)(arg1)->GetChangedWindow();
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 {
26433 resultobj = wxPyMake_wxObject(result, (bool)0);
26434 }
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26442 PyObject *obj;
26443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26444 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
26445 return SWIG_Py_Void();
26446 }
26447
26448 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26449 return SWIG_Python_InitShadowInstance(args);
26450 }
26451
26452 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj = 0;
26454 int arg1 = (int) 0 ;
26455 wxQueryNewPaletteEvent *result = 0 ;
26456 int val1 ;
26457 int ecode1 = 0 ;
26458 PyObject * obj0 = 0 ;
26459 char * kwnames[] = {
26460 (char *) "winid", NULL
26461 };
26462
26463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26464 if (obj0) {
26465 ecode1 = SWIG_AsVal_int(obj0, &val1);
26466 if (!SWIG_IsOK(ecode1)) {
26467 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26468 }
26469 arg1 = static_cast< int >(val1);
26470 }
26471 {
26472 PyThreadState* __tstate = wxPyBeginAllowThreads();
26473 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26478 return resultobj;
26479 fail:
26480 return NULL;
26481 }
26482
26483
26484 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26485 PyObject *resultobj = 0;
26486 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26487 bool arg2 ;
26488 void *argp1 = 0 ;
26489 int res1 = 0 ;
26490 bool val2 ;
26491 int ecode2 = 0 ;
26492 PyObject * obj0 = 0 ;
26493 PyObject * obj1 = 0 ;
26494 char * kwnames[] = {
26495 (char *) "self",(char *) "realized", NULL
26496 };
26497
26498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26500 if (!SWIG_IsOK(res1)) {
26501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26502 }
26503 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26504 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26505 if (!SWIG_IsOK(ecode2)) {
26506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26507 }
26508 arg2 = static_cast< bool >(val2);
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 (arg1)->SetPaletteRealized(arg2);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_Py_Void();
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 PyObject *resultobj = 0;
26524 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26525 bool result;
26526 void *argp1 = 0 ;
26527 int res1 = 0 ;
26528 PyObject *swig_obj[1] ;
26529
26530 if (!args) SWIG_fail;
26531 swig_obj[0] = args;
26532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26533 if (!SWIG_IsOK(res1)) {
26534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26535 }
26536 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26537 {
26538 PyThreadState* __tstate = wxPyBeginAllowThreads();
26539 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26540 wxPyEndAllowThreads(__tstate);
26541 if (PyErr_Occurred()) SWIG_fail;
26542 }
26543 {
26544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26545 }
26546 return resultobj;
26547 fail:
26548 return NULL;
26549 }
26550
26551
26552 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26553 PyObject *obj;
26554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26555 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26556 return SWIG_Py_Void();
26557 }
26558
26559 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26560 return SWIG_Python_InitShadowInstance(args);
26561 }
26562
26563 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *resultobj = 0;
26565 wxNavigationKeyEvent *result = 0 ;
26566
26567 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26568 {
26569 PyThreadState* __tstate = wxPyBeginAllowThreads();
26570 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26571 wxPyEndAllowThreads(__tstate);
26572 if (PyErr_Occurred()) SWIG_fail;
26573 }
26574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26575 return resultobj;
26576 fail:
26577 return NULL;
26578 }
26579
26580
26581 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 PyObject *resultobj = 0;
26583 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26584 bool result;
26585 void *argp1 = 0 ;
26586 int res1 = 0 ;
26587 PyObject *swig_obj[1] ;
26588
26589 if (!args) SWIG_fail;
26590 swig_obj[0] = args;
26591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26592 if (!SWIG_IsOK(res1)) {
26593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26594 }
26595 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26596 {
26597 PyThreadState* __tstate = wxPyBeginAllowThreads();
26598 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26599 wxPyEndAllowThreads(__tstate);
26600 if (PyErr_Occurred()) SWIG_fail;
26601 }
26602 {
26603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26604 }
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj = 0;
26613 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26614 bool arg2 ;
26615 void *argp1 = 0 ;
26616 int res1 = 0 ;
26617 bool val2 ;
26618 int ecode2 = 0 ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 char * kwnames[] = {
26622 (char *) "self",(char *) "forward", NULL
26623 };
26624
26625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26627 if (!SWIG_IsOK(res1)) {
26628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26629 }
26630 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26631 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26632 if (!SWIG_IsOK(ecode2)) {
26633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26634 }
26635 arg2 = static_cast< bool >(val2);
26636 {
26637 PyThreadState* __tstate = wxPyBeginAllowThreads();
26638 (arg1)->SetDirection(arg2);
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 resultobj = SWIG_Py_Void();
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26650 PyObject *resultobj = 0;
26651 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26652 bool result;
26653 void *argp1 = 0 ;
26654 int res1 = 0 ;
26655 PyObject *swig_obj[1] ;
26656
26657 if (!args) SWIG_fail;
26658 swig_obj[0] = args;
26659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26660 if (!SWIG_IsOK(res1)) {
26661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26662 }
26663 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 {
26671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26672 }
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26680 PyObject *resultobj = 0;
26681 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26682 bool arg2 ;
26683 void *argp1 = 0 ;
26684 int res1 = 0 ;
26685 bool val2 ;
26686 int ecode2 = 0 ;
26687 PyObject * obj0 = 0 ;
26688 PyObject * obj1 = 0 ;
26689 char * kwnames[] = {
26690 (char *) "self",(char *) "ischange", NULL
26691 };
26692
26693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26695 if (!SWIG_IsOK(res1)) {
26696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26697 }
26698 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26700 if (!SWIG_IsOK(ecode2)) {
26701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26702 }
26703 arg2 = static_cast< bool >(val2);
26704 {
26705 PyThreadState* __tstate = wxPyBeginAllowThreads();
26706 (arg1)->SetWindowChange(arg2);
26707 wxPyEndAllowThreads(__tstate);
26708 if (PyErr_Occurred()) SWIG_fail;
26709 }
26710 resultobj = SWIG_Py_Void();
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26718 PyObject *resultobj = 0;
26719 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26720 bool result;
26721 void *argp1 = 0 ;
26722 int res1 = 0 ;
26723 PyObject *swig_obj[1] ;
26724
26725 if (!args) SWIG_fail;
26726 swig_obj[0] = args;
26727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26728 if (!SWIG_IsOK(res1)) {
26729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26730 }
26731 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26732 {
26733 PyThreadState* __tstate = wxPyBeginAllowThreads();
26734 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 {
26739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26740 }
26741 return resultobj;
26742 fail:
26743 return NULL;
26744 }
26745
26746
26747 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26748 PyObject *resultobj = 0;
26749 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26750 bool arg2 ;
26751 void *argp1 = 0 ;
26752 int res1 = 0 ;
26753 bool val2 ;
26754 int ecode2 = 0 ;
26755 PyObject * obj0 = 0 ;
26756 PyObject * obj1 = 0 ;
26757 char * kwnames[] = {
26758 (char *) "self",(char *) "bIs", NULL
26759 };
26760
26761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26763 if (!SWIG_IsOK(res1)) {
26764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26765 }
26766 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26770 }
26771 arg2 = static_cast< bool >(val2);
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 (arg1)->SetFromTab(arg2);
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 resultobj = SWIG_Py_Void();
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj = 0;
26787 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26788 long arg2 ;
26789 void *argp1 = 0 ;
26790 int res1 = 0 ;
26791 long val2 ;
26792 int ecode2 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 PyObject * obj1 = 0 ;
26795 char * kwnames[] = {
26796 (char *) "self",(char *) "flags", NULL
26797 };
26798
26799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26801 if (!SWIG_IsOK(res1)) {
26802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26803 }
26804 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26805 ecode2 = SWIG_AsVal_long(obj1, &val2);
26806 if (!SWIG_IsOK(ecode2)) {
26807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26808 }
26809 arg2 = static_cast< long >(val2);
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 (arg1)->SetFlags(arg2);
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 resultobj = SWIG_Py_Void();
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26824 PyObject *resultobj = 0;
26825 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26826 wxWindow *result = 0 ;
26827 void *argp1 = 0 ;
26828 int res1 = 0 ;
26829 PyObject *swig_obj[1] ;
26830
26831 if (!args) SWIG_fail;
26832 swig_obj[0] = args;
26833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26834 if (!SWIG_IsOK(res1)) {
26835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26836 }
26837 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 {
26845 resultobj = wxPyMake_wxObject(result, (bool)0);
26846 }
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26856 wxWindow *arg2 = (wxWindow *) 0 ;
26857 void *argp1 = 0 ;
26858 int res1 = 0 ;
26859 void *argp2 = 0 ;
26860 int res2 = 0 ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char * kwnames[] = {
26864 (char *) "self",(char *) "win", NULL
26865 };
26866
26867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26869 if (!SWIG_IsOK(res1)) {
26870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26871 }
26872 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26873 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26874 if (!SWIG_IsOK(res2)) {
26875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26876 }
26877 arg2 = reinterpret_cast< wxWindow * >(argp2);
26878 {
26879 PyThreadState* __tstate = wxPyBeginAllowThreads();
26880 (arg1)->SetCurrentFocus(arg2);
26881 wxPyEndAllowThreads(__tstate);
26882 if (PyErr_Occurred()) SWIG_fail;
26883 }
26884 resultobj = SWIG_Py_Void();
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26892 PyObject *obj;
26893 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26894 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26895 return SWIG_Py_Void();
26896 }
26897
26898 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26899 return SWIG_Python_InitShadowInstance(args);
26900 }
26901
26902 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26903 PyObject *resultobj = 0;
26904 wxWindow *arg1 = (wxWindow *) NULL ;
26905 wxWindowCreateEvent *result = 0 ;
26906 void *argp1 = 0 ;
26907 int res1 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 char * kwnames[] = {
26910 (char *) "win", NULL
26911 };
26912
26913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26914 if (obj0) {
26915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26916 if (!SWIG_IsOK(res1)) {
26917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26918 }
26919 arg1 = reinterpret_cast< wxWindow * >(argp1);
26920 }
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26924 wxPyEndAllowThreads(__tstate);
26925 if (PyErr_Occurred()) SWIG_fail;
26926 }
26927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26928 return resultobj;
26929 fail:
26930 return NULL;
26931 }
26932
26933
26934 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26935 PyObject *resultobj = 0;
26936 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26937 wxWindow *result = 0 ;
26938 void *argp1 = 0 ;
26939 int res1 = 0 ;
26940 PyObject *swig_obj[1] ;
26941
26942 if (!args) SWIG_fail;
26943 swig_obj[0] = args;
26944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26945 if (!SWIG_IsOK(res1)) {
26946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26947 }
26948 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 {
26956 resultobj = wxPyMake_wxObject(result, (bool)0);
26957 }
26958 return resultobj;
26959 fail:
26960 return NULL;
26961 }
26962
26963
26964 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26965 PyObject *obj;
26966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26967 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26968 return SWIG_Py_Void();
26969 }
26970
26971 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26972 return SWIG_Python_InitShadowInstance(args);
26973 }
26974
26975 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26976 PyObject *resultobj = 0;
26977 wxWindow *arg1 = (wxWindow *) NULL ;
26978 wxWindowDestroyEvent *result = 0 ;
26979 void *argp1 = 0 ;
26980 int res1 = 0 ;
26981 PyObject * obj0 = 0 ;
26982 char * kwnames[] = {
26983 (char *) "win", NULL
26984 };
26985
26986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26987 if (obj0) {
26988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26989 if (!SWIG_IsOK(res1)) {
26990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26991 }
26992 arg1 = reinterpret_cast< wxWindow * >(argp1);
26993 }
26994 {
26995 PyThreadState* __tstate = wxPyBeginAllowThreads();
26996 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26997 wxPyEndAllowThreads(__tstate);
26998 if (PyErr_Occurred()) SWIG_fail;
26999 }
27000 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
27001 return resultobj;
27002 fail:
27003 return NULL;
27004 }
27005
27006
27007 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27008 PyObject *resultobj = 0;
27009 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
27010 wxWindow *result = 0 ;
27011 void *argp1 = 0 ;
27012 int res1 = 0 ;
27013 PyObject *swig_obj[1] ;
27014
27015 if (!args) SWIG_fail;
27016 swig_obj[0] = args;
27017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
27018 if (!SWIG_IsOK(res1)) {
27019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
27020 }
27021 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
27022 {
27023 PyThreadState* __tstate = wxPyBeginAllowThreads();
27024 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
27025 wxPyEndAllowThreads(__tstate);
27026 if (PyErr_Occurred()) SWIG_fail;
27027 }
27028 {
27029 resultobj = wxPyMake_wxObject(result, (bool)0);
27030 }
27031 return resultobj;
27032 fail:
27033 return NULL;
27034 }
27035
27036
27037 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27038 PyObject *obj;
27039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27040 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
27041 return SWIG_Py_Void();
27042 }
27043
27044 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 return SWIG_Python_InitShadowInstance(args);
27046 }
27047
27048 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27049 PyObject *resultobj = 0;
27050 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27051 int arg2 = (int) 0 ;
27052 wxPoint const &arg3_defvalue = wxDefaultPosition ;
27053 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
27054 wxContextMenuEvent *result = 0 ;
27055 int val1 ;
27056 int ecode1 = 0 ;
27057 int val2 ;
27058 int ecode2 = 0 ;
27059 wxPoint temp3 ;
27060 PyObject * obj0 = 0 ;
27061 PyObject * obj1 = 0 ;
27062 PyObject * obj2 = 0 ;
27063 char * kwnames[] = {
27064 (char *) "type",(char *) "winid",(char *) "pt", NULL
27065 };
27066
27067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27068 if (obj0) {
27069 ecode1 = SWIG_AsVal_int(obj0, &val1);
27070 if (!SWIG_IsOK(ecode1)) {
27071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27072 }
27073 arg1 = static_cast< wxEventType >(val1);
27074 }
27075 if (obj1) {
27076 ecode2 = SWIG_AsVal_int(obj1, &val2);
27077 if (!SWIG_IsOK(ecode2)) {
27078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
27079 }
27080 arg2 = static_cast< int >(val2);
27081 }
27082 if (obj2) {
27083 {
27084 arg3 = &temp3;
27085 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
27086 }
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *resultobj = 0;
27103 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27104 wxPoint *result = 0 ;
27105 void *argp1 = 0 ;
27106 int res1 = 0 ;
27107 PyObject *swig_obj[1] ;
27108
27109 if (!args) SWIG_fail;
27110 swig_obj[0] = args;
27111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27112 if (!SWIG_IsOK(res1)) {
27113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
27114 }
27115 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27116 {
27117 PyThreadState* __tstate = wxPyBeginAllowThreads();
27118 {
27119 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
27120 result = (wxPoint *) &_result_ref;
27121 }
27122 wxPyEndAllowThreads(__tstate);
27123 if (PyErr_Occurred()) SWIG_fail;
27124 }
27125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
27126 return resultobj;
27127 fail:
27128 return NULL;
27129 }
27130
27131
27132 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27133 PyObject *resultobj = 0;
27134 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
27135 wxPoint *arg2 = 0 ;
27136 void *argp1 = 0 ;
27137 int res1 = 0 ;
27138 wxPoint temp2 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "self",(char *) "pos", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
27146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
27147 if (!SWIG_IsOK(res1)) {
27148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
27149 }
27150 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
27151 {
27152 arg2 = &temp2;
27153 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27154 }
27155 {
27156 PyThreadState* __tstate = wxPyBeginAllowThreads();
27157 (arg1)->SetPosition((wxPoint const &)*arg2);
27158 wxPyEndAllowThreads(__tstate);
27159 if (PyErr_Occurred()) SWIG_fail;
27160 }
27161 resultobj = SWIG_Py_Void();
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27169 PyObject *obj;
27170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27171 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
27172 return SWIG_Py_Void();
27173 }
27174
27175 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27176 return SWIG_Python_InitShadowInstance(args);
27177 }
27178
27179 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27180 PyObject *resultobj = 0;
27181 wxIdleEvent *result = 0 ;
27182
27183 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 result = (wxIdleEvent *)new wxIdleEvent();
27187 wxPyEndAllowThreads(__tstate);
27188 if (PyErr_Occurred()) SWIG_fail;
27189 }
27190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
27191 return resultobj;
27192 fail:
27193 return NULL;
27194 }
27195
27196
27197 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27198 PyObject *resultobj = 0;
27199 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27200 bool arg2 = (bool) true ;
27201 void *argp1 = 0 ;
27202 int res1 = 0 ;
27203 bool val2 ;
27204 int ecode2 = 0 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char * kwnames[] = {
27208 (char *) "self",(char *) "needMore", NULL
27209 };
27210
27211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
27212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27213 if (!SWIG_IsOK(res1)) {
27214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
27215 }
27216 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27217 if (obj1) {
27218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27219 if (!SWIG_IsOK(ecode2)) {
27220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
27221 }
27222 arg2 = static_cast< bool >(val2);
27223 }
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 (arg1)->RequestMore(arg2);
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 resultobj = SWIG_Py_Void();
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27238 PyObject *resultobj = 0;
27239 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
27240 bool result;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 PyObject *swig_obj[1] ;
27244
27245 if (!args) SWIG_fail;
27246 swig_obj[0] = args;
27247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
27248 if (!SWIG_IsOK(res1)) {
27249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
27250 }
27251 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
27252 {
27253 PyThreadState* __tstate = wxPyBeginAllowThreads();
27254 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
27255 wxPyEndAllowThreads(__tstate);
27256 if (PyErr_Occurred()) SWIG_fail;
27257 }
27258 {
27259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27260 }
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj = 0;
27269 wxIdleMode arg1 ;
27270 int val1 ;
27271 int ecode1 = 0 ;
27272 PyObject * obj0 = 0 ;
27273 char * kwnames[] = {
27274 (char *) "mode", NULL
27275 };
27276
27277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
27278 ecode1 = SWIG_AsVal_int(obj0, &val1);
27279 if (!SWIG_IsOK(ecode1)) {
27280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
27281 }
27282 arg1 = static_cast< wxIdleMode >(val1);
27283 {
27284 PyThreadState* __tstate = wxPyBeginAllowThreads();
27285 wxIdleEvent::SetMode(arg1);
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 resultobj = SWIG_Py_Void();
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27297 PyObject *resultobj = 0;
27298 wxIdleMode result;
27299
27300 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
27301 {
27302 PyThreadState* __tstate = wxPyBeginAllowThreads();
27303 result = (wxIdleMode)wxIdleEvent::GetMode();
27304 wxPyEndAllowThreads(__tstate);
27305 if (PyErr_Occurred()) SWIG_fail;
27306 }
27307 resultobj = SWIG_From_int(static_cast< int >(result));
27308 return resultobj;
27309 fail:
27310 return NULL;
27311 }
27312
27313
27314 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27315 PyObject *resultobj = 0;
27316 wxWindow *arg1 = (wxWindow *) 0 ;
27317 bool result;
27318 void *argp1 = 0 ;
27319 int res1 = 0 ;
27320 PyObject * obj0 = 0 ;
27321 char * kwnames[] = {
27322 (char *) "win", NULL
27323 };
27324
27325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
27326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
27329 }
27330 arg1 = reinterpret_cast< wxWindow * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = (bool)wxIdleEvent::CanSend(arg1);
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27347 PyObject *obj;
27348 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27349 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
27350 return SWIG_Py_Void();
27351 }
27352
27353 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27354 return SWIG_Python_InitShadowInstance(args);
27355 }
27356
27357 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27358 PyObject *resultobj = 0;
27359 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27360 int arg2 = (int) 0 ;
27361 wxClipboardTextEvent *result = 0 ;
27362 int val1 ;
27363 int ecode1 = 0 ;
27364 int val2 ;
27365 int ecode2 = 0 ;
27366 PyObject * obj0 = 0 ;
27367 PyObject * obj1 = 0 ;
27368 char * kwnames[] = {
27369 (char *) "type",(char *) "winid", NULL
27370 };
27371
27372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27373 if (obj0) {
27374 ecode1 = SWIG_AsVal_int(obj0, &val1);
27375 if (!SWIG_IsOK(ecode1)) {
27376 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27377 }
27378 arg1 = static_cast< wxEventType >(val1);
27379 }
27380 if (obj1) {
27381 ecode2 = SWIG_AsVal_int(obj1, &val2);
27382 if (!SWIG_IsOK(ecode2)) {
27383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
27384 }
27385 arg2 = static_cast< int >(val2);
27386 }
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
27394 return resultobj;
27395 fail:
27396 return NULL;
27397 }
27398
27399
27400 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27401 PyObject *obj;
27402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27403 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
27404 return SWIG_Py_Void();
27405 }
27406
27407 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27408 return SWIG_Python_InitShadowInstance(args);
27409 }
27410
27411 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27412 PyObject *resultobj = 0;
27413 int arg1 = (int) 0 ;
27414 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
27415 wxPyEvent *result = 0 ;
27416 int val1 ;
27417 int ecode1 = 0 ;
27418 int val2 ;
27419 int ecode2 = 0 ;
27420 PyObject * obj0 = 0 ;
27421 PyObject * obj1 = 0 ;
27422 char * kwnames[] = {
27423 (char *) "winid",(char *) "eventType", NULL
27424 };
27425
27426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27427 if (obj0) {
27428 ecode1 = SWIG_AsVal_int(obj0, &val1);
27429 if (!SWIG_IsOK(ecode1)) {
27430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
27431 }
27432 arg1 = static_cast< int >(val1);
27433 }
27434 if (obj1) {
27435 ecode2 = SWIG_AsVal_int(obj1, &val2);
27436 if (!SWIG_IsOK(ecode2)) {
27437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
27438 }
27439 arg2 = static_cast< wxEventType >(val2);
27440 }
27441 {
27442 PyThreadState* __tstate = wxPyBeginAllowThreads();
27443 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27455 PyObject *resultobj = 0;
27456 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27457 void *argp1 = 0 ;
27458 int res1 = 0 ;
27459 PyObject *swig_obj[1] ;
27460
27461 if (!args) SWIG_fail;
27462 swig_obj[0] = args;
27463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27464 if (!SWIG_IsOK(res1)) {
27465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27466 }
27467 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 delete arg1;
27471
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27483 PyObject *resultobj = 0;
27484 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27485 PyObject *arg2 = (PyObject *) 0 ;
27486 void *argp1 = 0 ;
27487 int res1 = 0 ;
27488 PyObject * obj0 = 0 ;
27489 PyObject * obj1 = 0 ;
27490 char * kwnames[] = {
27491 (char *) "self",(char *) "self", NULL
27492 };
27493
27494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27498 }
27499 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27500 arg2 = obj1;
27501 {
27502 PyThreadState* __tstate = wxPyBeginAllowThreads();
27503 (arg1)->SetSelf(arg2);
27504 wxPyEndAllowThreads(__tstate);
27505 if (PyErr_Occurred()) SWIG_fail;
27506 }
27507 resultobj = SWIG_Py_Void();
27508 return resultobj;
27509 fail:
27510 return NULL;
27511 }
27512
27513
27514 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27515 PyObject *resultobj = 0;
27516 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27517 PyObject *result = 0 ;
27518 void *argp1 = 0 ;
27519 int res1 = 0 ;
27520 PyObject *swig_obj[1] ;
27521
27522 if (!args) SWIG_fail;
27523 swig_obj[0] = args;
27524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27525 if (!SWIG_IsOK(res1)) {
27526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27527 }
27528 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27529 {
27530 PyThreadState* __tstate = wxPyBeginAllowThreads();
27531 result = (PyObject *)(arg1)->GetSelf();
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 resultobj = result;
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27543 PyObject *obj;
27544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27545 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27546 return SWIG_Py_Void();
27547 }
27548
27549 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27550 return SWIG_Python_InitShadowInstance(args);
27551 }
27552
27553 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27554 PyObject *resultobj = 0;
27555 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27556 int arg2 = (int) 0 ;
27557 wxPyCommandEvent *result = 0 ;
27558 int val1 ;
27559 int ecode1 = 0 ;
27560 int val2 ;
27561 int ecode2 = 0 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char * kwnames[] = {
27565 (char *) "eventType",(char *) "id", NULL
27566 };
27567
27568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27569 if (obj0) {
27570 ecode1 = SWIG_AsVal_int(obj0, &val1);
27571 if (!SWIG_IsOK(ecode1)) {
27572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27573 }
27574 arg1 = static_cast< wxEventType >(val1);
27575 }
27576 if (obj1) {
27577 ecode2 = SWIG_AsVal_int(obj1, &val2);
27578 if (!SWIG_IsOK(ecode2)) {
27579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27580 }
27581 arg2 = static_cast< int >(val2);
27582 }
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27586 wxPyEndAllowThreads(__tstate);
27587 if (PyErr_Occurred()) SWIG_fail;
27588 }
27589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27590 return resultobj;
27591 fail:
27592 return NULL;
27593 }
27594
27595
27596 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27597 PyObject *resultobj = 0;
27598 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27608 }
27609 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 delete arg1;
27613
27614 wxPyEndAllowThreads(__tstate);
27615 if (PyErr_Occurred()) SWIG_fail;
27616 }
27617 resultobj = SWIG_Py_Void();
27618 return resultobj;
27619 fail:
27620 return NULL;
27621 }
27622
27623
27624 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27625 PyObject *resultobj = 0;
27626 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27627 PyObject *arg2 = (PyObject *) 0 ;
27628 void *argp1 = 0 ;
27629 int res1 = 0 ;
27630 PyObject * obj0 = 0 ;
27631 PyObject * obj1 = 0 ;
27632 char * kwnames[] = {
27633 (char *) "self",(char *) "self", NULL
27634 };
27635
27636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27638 if (!SWIG_IsOK(res1)) {
27639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27640 }
27641 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27642 arg2 = obj1;
27643 {
27644 PyThreadState* __tstate = wxPyBeginAllowThreads();
27645 (arg1)->SetSelf(arg2);
27646 wxPyEndAllowThreads(__tstate);
27647 if (PyErr_Occurred()) SWIG_fail;
27648 }
27649 resultobj = SWIG_Py_Void();
27650 return resultobj;
27651 fail:
27652 return NULL;
27653 }
27654
27655
27656 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27657 PyObject *resultobj = 0;
27658 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27659 PyObject *result = 0 ;
27660 void *argp1 = 0 ;
27661 int res1 = 0 ;
27662 PyObject *swig_obj[1] ;
27663
27664 if (!args) SWIG_fail;
27665 swig_obj[0] = args;
27666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27667 if (!SWIG_IsOK(res1)) {
27668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27669 }
27670 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27671 {
27672 PyThreadState* __tstate = wxPyBeginAllowThreads();
27673 result = (PyObject *)(arg1)->GetSelf();
27674 wxPyEndAllowThreads(__tstate);
27675 if (PyErr_Occurred()) SWIG_fail;
27676 }
27677 resultobj = result;
27678 return resultobj;
27679 fail:
27680 return NULL;
27681 }
27682
27683
27684 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27685 PyObject *obj;
27686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27687 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27688 return SWIG_Py_Void();
27689 }
27690
27691 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27692 return SWIG_Python_InitShadowInstance(args);
27693 }
27694
27695 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27696 PyObject *resultobj = 0;
27697 wxWindow *arg1 = (wxWindow *) 0 ;
27698 wxDateTime *arg2 = 0 ;
27699 wxEventType arg3 ;
27700 wxDateEvent *result = 0 ;
27701 void *argp1 = 0 ;
27702 int res1 = 0 ;
27703 void *argp2 = 0 ;
27704 int res2 = 0 ;
27705 int val3 ;
27706 int ecode3 = 0 ;
27707 PyObject * obj0 = 0 ;
27708 PyObject * obj1 = 0 ;
27709 PyObject * obj2 = 0 ;
27710 char * kwnames[] = {
27711 (char *) "win",(char *) "dt",(char *) "type", NULL
27712 };
27713
27714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27716 if (!SWIG_IsOK(res1)) {
27717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27718 }
27719 arg1 = reinterpret_cast< wxWindow * >(argp1);
27720 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27721 if (!SWIG_IsOK(res2)) {
27722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27723 }
27724 if (!argp2) {
27725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27726 }
27727 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27728 ecode3 = SWIG_AsVal_int(obj2, &val3);
27729 if (!SWIG_IsOK(ecode3)) {
27730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27731 }
27732 arg3 = static_cast< wxEventType >(val3);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27747 PyObject *resultobj = 0;
27748 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27749 wxDateTime *result = 0 ;
27750 void *argp1 = 0 ;
27751 int res1 = 0 ;
27752 PyObject *swig_obj[1] ;
27753
27754 if (!args) SWIG_fail;
27755 swig_obj[0] = args;
27756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27757 if (!SWIG_IsOK(res1)) {
27758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27759 }
27760 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27761 {
27762 PyThreadState* __tstate = wxPyBeginAllowThreads();
27763 {
27764 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27765 result = (wxDateTime *) &_result_ref;
27766 }
27767 wxPyEndAllowThreads(__tstate);
27768 if (PyErr_Occurred()) SWIG_fail;
27769 }
27770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27771 return resultobj;
27772 fail:
27773 return NULL;
27774 }
27775
27776
27777 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj = 0;
27779 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27780 wxDateTime *arg2 = 0 ;
27781 void *argp1 = 0 ;
27782 int res1 = 0 ;
27783 void *argp2 = 0 ;
27784 int res2 = 0 ;
27785 PyObject * obj0 = 0 ;
27786 PyObject * obj1 = 0 ;
27787 char * kwnames[] = {
27788 (char *) "self",(char *) "date", NULL
27789 };
27790
27791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27793 if (!SWIG_IsOK(res1)) {
27794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27795 }
27796 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27797 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27798 if (!SWIG_IsOK(res2)) {
27799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27800 }
27801 if (!argp2) {
27802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27803 }
27804 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 (arg1)->SetDate((wxDateTime const &)*arg2);
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_Py_Void();
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27819 PyObject *obj;
27820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27821 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27822 return SWIG_Py_Void();
27823 }
27824
27825 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27826 return SWIG_Python_InitShadowInstance(args);
27827 }
27828
27829 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27830 PyObject *resultobj = 0;
27831 wxPyApp *result = 0 ;
27832
27833 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27834 {
27835 PyThreadState* __tstate = wxPyBeginAllowThreads();
27836 result = (wxPyApp *)new_wxPyApp();
27837 wxPyEndAllowThreads(__tstate);
27838 if (PyErr_Occurred()) SWIG_fail;
27839 }
27840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27841 return resultobj;
27842 fail:
27843 return NULL;
27844 }
27845
27846
27847 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27848 PyObject *resultobj = 0;
27849 wxPyApp *arg1 = (wxPyApp *) 0 ;
27850 void *argp1 = 0 ;
27851 int res1 = 0 ;
27852 PyObject *swig_obj[1] ;
27853
27854 if (!args) SWIG_fail;
27855 swig_obj[0] = args;
27856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27859 }
27860 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 delete arg1;
27864
27865 wxPyEndAllowThreads(__tstate);
27866 if (PyErr_Occurred()) SWIG_fail;
27867 }
27868 resultobj = SWIG_Py_Void();
27869 return resultobj;
27870 fail:
27871 return NULL;
27872 }
27873
27874
27875 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27876 PyObject *resultobj = 0;
27877 wxPyApp *arg1 = (wxPyApp *) 0 ;
27878 PyObject *arg2 = (PyObject *) 0 ;
27879 PyObject *arg3 = (PyObject *) 0 ;
27880 bool arg4 ;
27881 void *argp1 = 0 ;
27882 int res1 = 0 ;
27883 bool val4 ;
27884 int ecode4 = 0 ;
27885 PyObject * obj0 = 0 ;
27886 PyObject * obj1 = 0 ;
27887 PyObject * obj2 = 0 ;
27888 PyObject * obj3 = 0 ;
27889 char * kwnames[] = {
27890 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27891 };
27892
27893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27895 if (!SWIG_IsOK(res1)) {
27896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27897 }
27898 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27899 arg2 = obj1;
27900 arg3 = obj2;
27901 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27902 if (!SWIG_IsOK(ecode4)) {
27903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27904 }
27905 arg4 = static_cast< bool >(val4);
27906 {
27907 PyThreadState* __tstate = wxPyBeginAllowThreads();
27908 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_Py_Void();
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27920 PyObject *resultobj = 0;
27921 wxPyApp *arg1 = (wxPyApp *) 0 ;
27922 wxString result;
27923 void *argp1 = 0 ;
27924 int res1 = 0 ;
27925 PyObject *swig_obj[1] ;
27926
27927 if (!args) SWIG_fail;
27928 swig_obj[0] = args;
27929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27930 if (!SWIG_IsOK(res1)) {
27931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27932 }
27933 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = ((wxPyApp const *)arg1)->GetAppName();
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 #if wxUSE_UNICODE
27942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27943 #else
27944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27945 #endif
27946 }
27947 return resultobj;
27948 fail:
27949 return NULL;
27950 }
27951
27952
27953 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27954 PyObject *resultobj = 0;
27955 wxPyApp *arg1 = (wxPyApp *) 0 ;
27956 wxString *arg2 = 0 ;
27957 void *argp1 = 0 ;
27958 int res1 = 0 ;
27959 bool temp2 = false ;
27960 PyObject * obj0 = 0 ;
27961 PyObject * obj1 = 0 ;
27962 char * kwnames[] = {
27963 (char *) "self",(char *) "name", NULL
27964 };
27965
27966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27968 if (!SWIG_IsOK(res1)) {
27969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27970 }
27971 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27972 {
27973 arg2 = wxString_in_helper(obj1);
27974 if (arg2 == NULL) SWIG_fail;
27975 temp2 = true;
27976 }
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 (arg1)->SetAppName((wxString const &)*arg2);
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 resultobj = SWIG_Py_Void();
27984 {
27985 if (temp2)
27986 delete arg2;
27987 }
27988 return resultobj;
27989 fail:
27990 {
27991 if (temp2)
27992 delete arg2;
27993 }
27994 return NULL;
27995 }
27996
27997
27998 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27999 PyObject *resultobj = 0;
28000 wxPyApp *arg1 = (wxPyApp *) 0 ;
28001 wxString result;
28002 void *argp1 = 0 ;
28003 int res1 = 0 ;
28004 PyObject *swig_obj[1] ;
28005
28006 if (!args) SWIG_fail;
28007 swig_obj[0] = args;
28008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28009 if (!SWIG_IsOK(res1)) {
28010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28011 }
28012 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28013 {
28014 PyThreadState* __tstate = wxPyBeginAllowThreads();
28015 result = ((wxPyApp const *)arg1)->GetClassName();
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 {
28020 #if wxUSE_UNICODE
28021 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28022 #else
28023 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28024 #endif
28025 }
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj = 0;
28034 wxPyApp *arg1 = (wxPyApp *) 0 ;
28035 wxString *arg2 = 0 ;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 bool temp2 = false ;
28039 PyObject * obj0 = 0 ;
28040 PyObject * obj1 = 0 ;
28041 char * kwnames[] = {
28042 (char *) "self",(char *) "name", NULL
28043 };
28044
28045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
28046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28047 if (!SWIG_IsOK(res1)) {
28048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28049 }
28050 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28051 {
28052 arg2 = wxString_in_helper(obj1);
28053 if (arg2 == NULL) SWIG_fail;
28054 temp2 = true;
28055 }
28056 {
28057 PyThreadState* __tstate = wxPyBeginAllowThreads();
28058 (arg1)->SetClassName((wxString const &)*arg2);
28059 wxPyEndAllowThreads(__tstate);
28060 if (PyErr_Occurred()) SWIG_fail;
28061 }
28062 resultobj = SWIG_Py_Void();
28063 {
28064 if (temp2)
28065 delete arg2;
28066 }
28067 return resultobj;
28068 fail:
28069 {
28070 if (temp2)
28071 delete arg2;
28072 }
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079 wxPyApp *arg1 = (wxPyApp *) 0 ;
28080 wxString *result = 0 ;
28081 void *argp1 = 0 ;
28082 int res1 = 0 ;
28083 PyObject *swig_obj[1] ;
28084
28085 if (!args) SWIG_fail;
28086 swig_obj[0] = args;
28087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28088 if (!SWIG_IsOK(res1)) {
28089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28090 }
28091 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28092 {
28093 PyThreadState* __tstate = wxPyBeginAllowThreads();
28094 {
28095 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
28096 result = (wxString *) &_result_ref;
28097 }
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 {
28102 #if wxUSE_UNICODE
28103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
28104 #else
28105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
28106 #endif
28107 }
28108 return resultobj;
28109 fail:
28110 return NULL;
28111 }
28112
28113
28114 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28115 PyObject *resultobj = 0;
28116 wxPyApp *arg1 = (wxPyApp *) 0 ;
28117 wxString *arg2 = 0 ;
28118 void *argp1 = 0 ;
28119 int res1 = 0 ;
28120 bool temp2 = false ;
28121 PyObject * obj0 = 0 ;
28122 PyObject * obj1 = 0 ;
28123 char * kwnames[] = {
28124 (char *) "self",(char *) "name", NULL
28125 };
28126
28127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
28128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28129 if (!SWIG_IsOK(res1)) {
28130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
28131 }
28132 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28133 {
28134 arg2 = wxString_in_helper(obj1);
28135 if (arg2 == NULL) SWIG_fail;
28136 temp2 = true;
28137 }
28138 {
28139 PyThreadState* __tstate = wxPyBeginAllowThreads();
28140 (arg1)->SetVendorName((wxString const &)*arg2);
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 resultobj = SWIG_Py_Void();
28145 {
28146 if (temp2)
28147 delete arg2;
28148 }
28149 return resultobj;
28150 fail:
28151 {
28152 if (temp2)
28153 delete arg2;
28154 }
28155 return NULL;
28156 }
28157
28158
28159 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28160 PyObject *resultobj = 0;
28161 wxPyApp *arg1 = (wxPyApp *) 0 ;
28162 wxAppTraits *result = 0 ;
28163 void *argp1 = 0 ;
28164 int res1 = 0 ;
28165 PyObject *swig_obj[1] ;
28166
28167 if (!args) SWIG_fail;
28168 swig_obj[0] = args;
28169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28170 if (!SWIG_IsOK(res1)) {
28171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
28172 }
28173 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 result = (wxAppTraits *)(arg1)->GetTraits();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 PyObject *resultobj = 0;
28189 wxPyApp *arg1 = (wxPyApp *) 0 ;
28190 void *argp1 = 0 ;
28191 int res1 = 0 ;
28192 PyObject *swig_obj[1] ;
28193
28194 if (!args) SWIG_fail;
28195 swig_obj[0] = args;
28196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28197 if (!SWIG_IsOK(res1)) {
28198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28199 }
28200 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28201 {
28202 PyThreadState* __tstate = wxPyBeginAllowThreads();
28203 (arg1)->ProcessPendingEvents();
28204 wxPyEndAllowThreads(__tstate);
28205 if (PyErr_Occurred()) SWIG_fail;
28206 }
28207 resultobj = SWIG_Py_Void();
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj = 0;
28216 wxPyApp *arg1 = (wxPyApp *) 0 ;
28217 bool arg2 = (bool) false ;
28218 bool result;
28219 void *argp1 = 0 ;
28220 int res1 = 0 ;
28221 bool val2 ;
28222 int ecode2 = 0 ;
28223 PyObject * obj0 = 0 ;
28224 PyObject * obj1 = 0 ;
28225 char * kwnames[] = {
28226 (char *) "self",(char *) "onlyIfNeeded", NULL
28227 };
28228
28229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
28230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28231 if (!SWIG_IsOK(res1)) {
28232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
28233 }
28234 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28235 if (obj1) {
28236 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28237 if (!SWIG_IsOK(ecode2)) {
28238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
28239 }
28240 arg2 = static_cast< bool >(val2);
28241 }
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (bool)(arg1)->Yield(arg2);
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 {
28249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28250 }
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28258 PyObject *resultobj = 0;
28259 wxPyApp *arg1 = (wxPyApp *) 0 ;
28260 void *argp1 = 0 ;
28261 int res1 = 0 ;
28262 PyObject *swig_obj[1] ;
28263
28264 if (!args) SWIG_fail;
28265 swig_obj[0] = args;
28266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28267 if (!SWIG_IsOK(res1)) {
28268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28269 }
28270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 (arg1)->WakeUpIdle();
28274 wxPyEndAllowThreads(__tstate);
28275 if (PyErr_Occurred()) SWIG_fail;
28276 }
28277 resultobj = SWIG_Py_Void();
28278 return resultobj;
28279 fail:
28280 return NULL;
28281 }
28282
28283
28284 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28285 PyObject *resultobj = 0;
28286 bool result;
28287
28288 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
28289 {
28290 PyThreadState* __tstate = wxPyBeginAllowThreads();
28291 result = (bool)wxPyApp::IsMainLoopRunning();
28292 wxPyEndAllowThreads(__tstate);
28293 if (PyErr_Occurred()) SWIG_fail;
28294 }
28295 {
28296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28297 }
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 wxPyApp *arg1 = (wxPyApp *) 0 ;
28307 int result;
28308 void *argp1 = 0 ;
28309 int res1 = 0 ;
28310 PyObject *swig_obj[1] ;
28311
28312 if (!args) SWIG_fail;
28313 swig_obj[0] = args;
28314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28315 if (!SWIG_IsOK(res1)) {
28316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28317 }
28318 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (int)(arg1)->MainLoop();
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_From_int(static_cast< int >(result));
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28333 PyObject *resultobj = 0;
28334 wxPyApp *arg1 = (wxPyApp *) 0 ;
28335 void *argp1 = 0 ;
28336 int res1 = 0 ;
28337 PyObject *swig_obj[1] ;
28338
28339 if (!args) SWIG_fail;
28340 swig_obj[0] = args;
28341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28342 if (!SWIG_IsOK(res1)) {
28343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
28344 }
28345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 (arg1)->Exit();
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 resultobj = SWIG_Py_Void();
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28360 PyObject *resultobj = 0;
28361 wxPyApp *arg1 = (wxPyApp *) 0 ;
28362 wxLayoutDirection result;
28363 void *argp1 = 0 ;
28364 int res1 = 0 ;
28365 PyObject *swig_obj[1] ;
28366
28367 if (!args) SWIG_fail;
28368 swig_obj[0] = args;
28369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28370 if (!SWIG_IsOK(res1)) {
28371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28372 }
28373 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 resultobj = SWIG_From_int(static_cast< int >(result));
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28388 PyObject *resultobj = 0;
28389 wxPyApp *arg1 = (wxPyApp *) 0 ;
28390 void *argp1 = 0 ;
28391 int res1 = 0 ;
28392 PyObject *swig_obj[1] ;
28393
28394 if (!args) SWIG_fail;
28395 swig_obj[0] = args;
28396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
28399 }
28400 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 (arg1)->ExitMainLoop();
28404 wxPyEndAllowThreads(__tstate);
28405 if (PyErr_Occurred()) SWIG_fail;
28406 }
28407 resultobj = SWIG_Py_Void();
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28415 PyObject *resultobj = 0;
28416 wxPyApp *arg1 = (wxPyApp *) 0 ;
28417 bool result;
28418 void *argp1 = 0 ;
28419 int res1 = 0 ;
28420 PyObject *swig_obj[1] ;
28421
28422 if (!args) SWIG_fail;
28423 swig_obj[0] = args;
28424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28425 if (!SWIG_IsOK(res1)) {
28426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
28427 }
28428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28429 {
28430 PyThreadState* __tstate = wxPyBeginAllowThreads();
28431 result = (bool)(arg1)->Pending();
28432 wxPyEndAllowThreads(__tstate);
28433 if (PyErr_Occurred()) SWIG_fail;
28434 }
28435 {
28436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28437 }
28438 return resultobj;
28439 fail:
28440 return NULL;
28441 }
28442
28443
28444 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28445 PyObject *resultobj = 0;
28446 wxPyApp *arg1 = (wxPyApp *) 0 ;
28447 bool result;
28448 void *argp1 = 0 ;
28449 int res1 = 0 ;
28450 PyObject *swig_obj[1] ;
28451
28452 if (!args) SWIG_fail;
28453 swig_obj[0] = args;
28454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28455 if (!SWIG_IsOK(res1)) {
28456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
28457 }
28458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (bool)(arg1)->Dispatch();
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28467 }
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxPyApp *arg1 = (wxPyApp *) 0 ;
28477 bool result;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 PyObject *swig_obj[1] ;
28481
28482 if (!args) SWIG_fail;
28483 swig_obj[0] = args;
28484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28485 if (!SWIG_IsOK(res1)) {
28486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28487 }
28488 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (bool)(arg1)->ProcessIdle();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj = 0;
28506 wxPyApp *arg1 = (wxPyApp *) 0 ;
28507 wxWindow *arg2 = (wxWindow *) 0 ;
28508 wxIdleEvent *arg3 = 0 ;
28509 bool result;
28510 void *argp1 = 0 ;
28511 int res1 = 0 ;
28512 void *argp2 = 0 ;
28513 int res2 = 0 ;
28514 void *argp3 = 0 ;
28515 int res3 = 0 ;
28516 PyObject * obj0 = 0 ;
28517 PyObject * obj1 = 0 ;
28518 PyObject * obj2 = 0 ;
28519 char * kwnames[] = {
28520 (char *) "self",(char *) "win",(char *) "event", NULL
28521 };
28522
28523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28525 if (!SWIG_IsOK(res1)) {
28526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28527 }
28528 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28530 if (!SWIG_IsOK(res2)) {
28531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28532 }
28533 arg2 = reinterpret_cast< wxWindow * >(argp2);
28534 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28535 if (!SWIG_IsOK(res3)) {
28536 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28537 }
28538 if (!argp3) {
28539 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28540 }
28541 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28558 PyObject *resultobj = 0;
28559 wxPyApp *arg1 = (wxPyApp *) 0 ;
28560 bool result;
28561 void *argp1 = 0 ;
28562 int res1 = 0 ;
28563 PyObject *swig_obj[1] ;
28564
28565 if (!args) SWIG_fail;
28566 swig_obj[0] = args;
28567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28570 }
28571 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (bool)((wxPyApp const *)arg1)->IsActive();
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 {
28579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28580 }
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj = 0;
28589 wxPyApp *arg1 = (wxPyApp *) 0 ;
28590 wxWindow *arg2 = (wxWindow *) 0 ;
28591 void *argp1 = 0 ;
28592 int res1 = 0 ;
28593 void *argp2 = 0 ;
28594 int res2 = 0 ;
28595 PyObject * obj0 = 0 ;
28596 PyObject * obj1 = 0 ;
28597 char * kwnames[] = {
28598 (char *) "self",(char *) "win", NULL
28599 };
28600
28601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28603 if (!SWIG_IsOK(res1)) {
28604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28605 }
28606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28608 if (!SWIG_IsOK(res2)) {
28609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28610 }
28611 arg2 = reinterpret_cast< wxWindow * >(argp2);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 (arg1)->SetTopWindow(arg2);
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 resultobj = SWIG_Py_Void();
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28626 PyObject *resultobj = 0;
28627 wxPyApp *arg1 = (wxPyApp *) 0 ;
28628 wxWindow *result = 0 ;
28629 void *argp1 = 0 ;
28630 int res1 = 0 ;
28631 PyObject *swig_obj[1] ;
28632
28633 if (!args) SWIG_fail;
28634 swig_obj[0] = args;
28635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28636 if (!SWIG_IsOK(res1)) {
28637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28638 }
28639 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = wxPyMake_wxObject(result, (bool)0);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj = 0;
28657 wxPyApp *arg1 = (wxPyApp *) 0 ;
28658 bool arg2 ;
28659 void *argp1 = 0 ;
28660 int res1 = 0 ;
28661 bool val2 ;
28662 int ecode2 = 0 ;
28663 PyObject * obj0 = 0 ;
28664 PyObject * obj1 = 0 ;
28665 char * kwnames[] = {
28666 (char *) "self",(char *) "flag", NULL
28667 };
28668
28669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28671 if (!SWIG_IsOK(res1)) {
28672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28673 }
28674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28676 if (!SWIG_IsOK(ecode2)) {
28677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28678 }
28679 arg2 = static_cast< bool >(val2);
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 (arg1)->SetExitOnFrameDelete(arg2);
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 resultobj = SWIG_Py_Void();
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28694 PyObject *resultobj = 0;
28695 wxPyApp *arg1 = (wxPyApp *) 0 ;
28696 bool result;
28697 void *argp1 = 0 ;
28698 int res1 = 0 ;
28699 PyObject *swig_obj[1] ;
28700
28701 if (!args) SWIG_fail;
28702 swig_obj[0] = args;
28703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28704 if (!SWIG_IsOK(res1)) {
28705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28706 }
28707 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28708 {
28709 PyThreadState* __tstate = wxPyBeginAllowThreads();
28710 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28711 wxPyEndAllowThreads(__tstate);
28712 if (PyErr_Occurred()) SWIG_fail;
28713 }
28714 {
28715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28716 }
28717 return resultobj;
28718 fail:
28719 return NULL;
28720 }
28721
28722
28723 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28724 PyObject *resultobj = 0;
28725 wxPyApp *arg1 = (wxPyApp *) 0 ;
28726 bool arg2 ;
28727 void *argp1 = 0 ;
28728 int res1 = 0 ;
28729 bool val2 ;
28730 int ecode2 = 0 ;
28731 PyObject * obj0 = 0 ;
28732 PyObject * obj1 = 0 ;
28733 char * kwnames[] = {
28734 (char *) "self",(char *) "flag", NULL
28735 };
28736
28737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28739 if (!SWIG_IsOK(res1)) {
28740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28741 }
28742 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28743 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28744 if (!SWIG_IsOK(ecode2)) {
28745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28746 }
28747 arg2 = static_cast< bool >(val2);
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 (arg1)->SetUseBestVisual(arg2);
28751 wxPyEndAllowThreads(__tstate);
28752 if (PyErr_Occurred()) SWIG_fail;
28753 }
28754 resultobj = SWIG_Py_Void();
28755 return resultobj;
28756 fail:
28757 return NULL;
28758 }
28759
28760
28761 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28762 PyObject *resultobj = 0;
28763 wxPyApp *arg1 = (wxPyApp *) 0 ;
28764 bool result;
28765 void *argp1 = 0 ;
28766 int res1 = 0 ;
28767 PyObject *swig_obj[1] ;
28768
28769 if (!args) SWIG_fail;
28770 swig_obj[0] = args;
28771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28772 if (!SWIG_IsOK(res1)) {
28773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28774 }
28775 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28776 {
28777 PyThreadState* __tstate = wxPyBeginAllowThreads();
28778 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28779 wxPyEndAllowThreads(__tstate);
28780 if (PyErr_Occurred()) SWIG_fail;
28781 }
28782 {
28783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28784 }
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28792 PyObject *resultobj = 0;
28793 wxPyApp *arg1 = (wxPyApp *) 0 ;
28794 int arg2 ;
28795 void *argp1 = 0 ;
28796 int res1 = 0 ;
28797 int val2 ;
28798 int ecode2 = 0 ;
28799 PyObject * obj0 = 0 ;
28800 PyObject * obj1 = 0 ;
28801 char * kwnames[] = {
28802 (char *) "self",(char *) "mode", NULL
28803 };
28804
28805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28807 if (!SWIG_IsOK(res1)) {
28808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28809 }
28810 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28811 ecode2 = SWIG_AsVal_int(obj1, &val2);
28812 if (!SWIG_IsOK(ecode2)) {
28813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28814 }
28815 arg2 = static_cast< int >(val2);
28816 {
28817 PyThreadState* __tstate = wxPyBeginAllowThreads();
28818 (arg1)->SetPrintMode(arg2);
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 resultobj = SWIG_Py_Void();
28823 return resultobj;
28824 fail:
28825 return NULL;
28826 }
28827
28828
28829 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28830 PyObject *resultobj = 0;
28831 wxPyApp *arg1 = (wxPyApp *) 0 ;
28832 int result;
28833 void *argp1 = 0 ;
28834 int res1 = 0 ;
28835 PyObject *swig_obj[1] ;
28836
28837 if (!args) SWIG_fail;
28838 swig_obj[0] = args;
28839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28840 if (!SWIG_IsOK(res1)) {
28841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28842 }
28843 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28844 {
28845 PyThreadState* __tstate = wxPyBeginAllowThreads();
28846 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28847 wxPyEndAllowThreads(__tstate);
28848 if (PyErr_Occurred()) SWIG_fail;
28849 }
28850 resultobj = SWIG_From_int(static_cast< int >(result));
28851 return resultobj;
28852 fail:
28853 return NULL;
28854 }
28855
28856
28857 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28858 PyObject *resultobj = 0;
28859 wxPyApp *arg1 = (wxPyApp *) 0 ;
28860 int arg2 ;
28861 void *argp1 = 0 ;
28862 int res1 = 0 ;
28863 int val2 ;
28864 int ecode2 = 0 ;
28865 PyObject * obj0 = 0 ;
28866 PyObject * obj1 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "self",(char *) "mode", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28875 }
28876 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28877 ecode2 = SWIG_AsVal_int(obj1, &val2);
28878 if (!SWIG_IsOK(ecode2)) {
28879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28880 }
28881 arg2 = static_cast< int >(val2);
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->SetAssertMode(arg2);
28885 wxPyEndAllowThreads(__tstate);
28886 if (PyErr_Occurred()) SWIG_fail;
28887 }
28888 resultobj = SWIG_Py_Void();
28889 return resultobj;
28890 fail:
28891 return NULL;
28892 }
28893
28894
28895 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 PyObject *resultobj = 0;
28897 wxPyApp *arg1 = (wxPyApp *) 0 ;
28898 int result;
28899 void *argp1 = 0 ;
28900 int res1 = 0 ;
28901 PyObject *swig_obj[1] ;
28902
28903 if (!args) SWIG_fail;
28904 swig_obj[0] = args;
28905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28906 if (!SWIG_IsOK(res1)) {
28907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28908 }
28909 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28910 {
28911 PyThreadState* __tstate = wxPyBeginAllowThreads();
28912 result = (int)(arg1)->GetAssertMode();
28913 wxPyEndAllowThreads(__tstate);
28914 if (PyErr_Occurred()) SWIG_fail;
28915 }
28916 resultobj = SWIG_From_int(static_cast< int >(result));
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28924 PyObject *resultobj = 0;
28925 bool result;
28926
28927 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28928 {
28929 PyThreadState* __tstate = wxPyBeginAllowThreads();
28930 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28931 wxPyEndAllowThreads(__tstate);
28932 if (PyErr_Occurred()) SWIG_fail;
28933 }
28934 {
28935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28936 }
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 long result;
28946
28947 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28948 {
28949 PyThreadState* __tstate = wxPyBeginAllowThreads();
28950 result = (long)wxPyApp::GetMacAboutMenuItemId();
28951 wxPyEndAllowThreads(__tstate);
28952 if (PyErr_Occurred()) SWIG_fail;
28953 }
28954 resultobj = SWIG_From_long(static_cast< long >(result));
28955 return resultobj;
28956 fail:
28957 return NULL;
28958 }
28959
28960
28961 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 PyObject *resultobj = 0;
28963 long result;
28964
28965 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28969 wxPyEndAllowThreads(__tstate);
28970 if (PyErr_Occurred()) SWIG_fail;
28971 }
28972 resultobj = SWIG_From_long(static_cast< long >(result));
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28980 PyObject *resultobj = 0;
28981 long result;
28982
28983 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (long)wxPyApp::GetMacExitMenuItemId();
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_From_long(static_cast< long >(result));
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxString result;
29000
29001 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = wxPyApp::GetMacHelpMenuTitleName();
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 {
29009 #if wxUSE_UNICODE
29010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29011 #else
29012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29013 #endif
29014 }
29015 return resultobj;
29016 fail:
29017 return NULL;
29018 }
29019
29020
29021 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29022 PyObject *resultobj = 0;
29023 bool arg1 ;
29024 bool val1 ;
29025 int ecode1 = 0 ;
29026 PyObject * obj0 = 0 ;
29027 char * kwnames[] = {
29028 (char *) "val", NULL
29029 };
29030
29031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
29032 ecode1 = SWIG_AsVal_bool(obj0, &val1);
29033 if (!SWIG_IsOK(ecode1)) {
29034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
29035 }
29036 arg1 = static_cast< bool >(val1);
29037 {
29038 PyThreadState* __tstate = wxPyBeginAllowThreads();
29039 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
29040 wxPyEndAllowThreads(__tstate);
29041 if (PyErr_Occurred()) SWIG_fail;
29042 }
29043 resultobj = SWIG_Py_Void();
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj = 0;
29052 long arg1 ;
29053 long val1 ;
29054 int ecode1 = 0 ;
29055 PyObject * obj0 = 0 ;
29056 char * kwnames[] = {
29057 (char *) "val", NULL
29058 };
29059
29060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
29061 ecode1 = SWIG_AsVal_long(obj0, &val1);
29062 if (!SWIG_IsOK(ecode1)) {
29063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
29064 }
29065 arg1 = static_cast< long >(val1);
29066 {
29067 PyThreadState* __tstate = wxPyBeginAllowThreads();
29068 wxPyApp::SetMacAboutMenuItemId(arg1);
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 resultobj = SWIG_Py_Void();
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 long arg1 ;
29082 long val1 ;
29083 int ecode1 = 0 ;
29084 PyObject * obj0 = 0 ;
29085 char * kwnames[] = {
29086 (char *) "val", NULL
29087 };
29088
29089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
29090 ecode1 = SWIG_AsVal_long(obj0, &val1);
29091 if (!SWIG_IsOK(ecode1)) {
29092 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
29093 }
29094 arg1 = static_cast< long >(val1);
29095 {
29096 PyThreadState* __tstate = wxPyBeginAllowThreads();
29097 wxPyApp::SetMacPreferencesMenuItemId(arg1);
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 resultobj = SWIG_Py_Void();
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj = 0;
29110 long arg1 ;
29111 long val1 ;
29112 int ecode1 = 0 ;
29113 PyObject * obj0 = 0 ;
29114 char * kwnames[] = {
29115 (char *) "val", NULL
29116 };
29117
29118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
29119 ecode1 = SWIG_AsVal_long(obj0, &val1);
29120 if (!SWIG_IsOK(ecode1)) {
29121 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
29122 }
29123 arg1 = static_cast< long >(val1);
29124 {
29125 PyThreadState* __tstate = wxPyBeginAllowThreads();
29126 wxPyApp::SetMacExitMenuItemId(arg1);
29127 wxPyEndAllowThreads(__tstate);
29128 if (PyErr_Occurred()) SWIG_fail;
29129 }
29130 resultobj = SWIG_Py_Void();
29131 return resultobj;
29132 fail:
29133 return NULL;
29134 }
29135
29136
29137 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 wxString *arg1 = 0 ;
29140 bool temp1 = false ;
29141 PyObject * obj0 = 0 ;
29142 char * kwnames[] = {
29143 (char *) "val", NULL
29144 };
29145
29146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
29147 {
29148 arg1 = wxString_in_helper(obj0);
29149 if (arg1 == NULL) SWIG_fail;
29150 temp1 = true;
29151 }
29152 {
29153 PyThreadState* __tstate = wxPyBeginAllowThreads();
29154 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
29155 wxPyEndAllowThreads(__tstate);
29156 if (PyErr_Occurred()) SWIG_fail;
29157 }
29158 resultobj = SWIG_Py_Void();
29159 {
29160 if (temp1)
29161 delete arg1;
29162 }
29163 return resultobj;
29164 fail:
29165 {
29166 if (temp1)
29167 delete arg1;
29168 }
29169 return NULL;
29170 }
29171
29172
29173 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29174 PyObject *resultobj = 0;
29175 wxPyApp *arg1 = (wxPyApp *) 0 ;
29176 void *argp1 = 0 ;
29177 int res1 = 0 ;
29178 PyObject *swig_obj[1] ;
29179
29180 if (!args) SWIG_fail;
29181 swig_obj[0] = args;
29182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29183 if (!SWIG_IsOK(res1)) {
29184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29185 }
29186 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29187 {
29188 PyThreadState* __tstate = wxPyBeginAllowThreads();
29189 (arg1)->_BootstrapApp();
29190 wxPyEndAllowThreads(__tstate);
29191 if (PyErr_Occurred()) SWIG_fail;
29192 }
29193 resultobj = SWIG_Py_Void();
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29201 PyObject *resultobj = 0;
29202 int result;
29203
29204 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 result = (int)wxPyApp_GetComCtl32Version();
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_From_int(static_cast< int >(result));
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *resultobj = 0;
29220 bool result;
29221
29222 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 result = (bool)wxPyApp_IsDisplayAvailable();
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 {
29230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29231 }
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 PyObject *obj;
29240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29241 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
29242 return SWIG_Py_Void();
29243 }
29244
29245 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29246 return SWIG_Python_InitShadowInstance(args);
29247 }
29248
29249 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29250 PyObject *resultobj = 0;
29251
29252 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 wxExit();
29256 wxPyEndAllowThreads(__tstate);
29257 if (PyErr_Occurred()) SWIG_fail;
29258 }
29259 resultobj = SWIG_Py_Void();
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29267 PyObject *resultobj = 0;
29268 bool result;
29269
29270 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 result = (bool)wxYield();
29274 wxPyEndAllowThreads(__tstate);
29275 if (PyErr_Occurred()) SWIG_fail;
29276 }
29277 {
29278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29279 }
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29287 PyObject *resultobj = 0;
29288 bool result;
29289
29290 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 result = (bool)wxYieldIfNeeded();
29294 wxPyEndAllowThreads(__tstate);
29295 if (PyErr_Occurred()) SWIG_fail;
29296 }
29297 {
29298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29299 }
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj = 0;
29308 wxWindow *arg1 = (wxWindow *) NULL ;
29309 bool arg2 = (bool) false ;
29310 bool result;
29311 void *argp1 = 0 ;
29312 int res1 = 0 ;
29313 bool val2 ;
29314 int ecode2 = 0 ;
29315 PyObject * obj0 = 0 ;
29316 PyObject * obj1 = 0 ;
29317 char * kwnames[] = {
29318 (char *) "win",(char *) "onlyIfNeeded", NULL
29319 };
29320
29321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
29322 if (obj0) {
29323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
29326 }
29327 arg1 = reinterpret_cast< wxWindow * >(argp1);
29328 }
29329 if (obj1) {
29330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29331 if (!SWIG_IsOK(ecode2)) {
29332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
29333 }
29334 arg2 = static_cast< bool >(val2);
29335 }
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (bool)wxSafeYield(arg1,arg2);
29339 wxPyEndAllowThreads(__tstate);
29340 if (PyErr_Occurred()) SWIG_fail;
29341 }
29342 {
29343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29344 }
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29352 PyObject *resultobj = 0;
29353
29354 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
29355 {
29356 PyThreadState* __tstate = wxPyBeginAllowThreads();
29357 wxWakeUpIdle();
29358 wxPyEndAllowThreads(__tstate);
29359 if (PyErr_Occurred()) SWIG_fail;
29360 }
29361 resultobj = SWIG_Py_Void();
29362 return resultobj;
29363 fail:
29364 return NULL;
29365 }
29366
29367
29368 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29369 PyObject *resultobj = 0;
29370 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
29371 wxEvent *arg2 = 0 ;
29372 void *argp1 = 0 ;
29373 int res1 = 0 ;
29374 void *argp2 = 0 ;
29375 int res2 = 0 ;
29376 PyObject * obj0 = 0 ;
29377 PyObject * obj1 = 0 ;
29378 char * kwnames[] = {
29379 (char *) "dest",(char *) "event", NULL
29380 };
29381
29382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
29384 if (!SWIG_IsOK(res1)) {
29385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
29386 }
29387 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
29388 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
29389 if (!SWIG_IsOK(res2)) {
29390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29391 }
29392 if (!argp2) {
29393 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
29394 }
29395 arg2 = reinterpret_cast< wxEvent * >(argp2);
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 wxPostEvent(arg1,*arg2);
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_Py_Void();
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *resultobj = 0;
29411
29412 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
29413 {
29414 PyThreadState* __tstate = wxPyBeginAllowThreads();
29415 wxApp_CleanUp();
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 resultobj = SWIG_Py_Void();
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29427 PyObject *resultobj = 0;
29428 wxPyApp *result = 0 ;
29429
29430 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (wxPyApp *)wxPyGetApp();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = wxPyMake_wxObject(result, 0);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 char *arg1 = (char *) 0 ;
29449 int res1 ;
29450 char *buf1 = 0 ;
29451 int alloc1 = 0 ;
29452 PyObject * obj0 = 0 ;
29453 char * kwnames[] = {
29454 (char *) "encoding", NULL
29455 };
29456
29457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
29458 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
29459 if (!SWIG_IsOK(res1)) {
29460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29461 }
29462 arg1 = buf1;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 wxSetDefaultPyEncoding((char const *)arg1);
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_Py_Void();
29470 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29471 return resultobj;
29472 fail:
29473 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29474 return NULL;
29475 }
29476
29477
29478 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29479 PyObject *resultobj = 0;
29480 char *result = 0 ;
29481
29482 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29483 {
29484 PyThreadState* __tstate = wxPyBeginAllowThreads();
29485 result = (char *)wxGetDefaultPyEncoding();
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 resultobj = SWIG_FromCharPtr(result);
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *resultobj = 0;
29498 wxEventLoop *result = 0 ;
29499
29500 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29501 {
29502 PyThreadState* __tstate = wxPyBeginAllowThreads();
29503 result = (wxEventLoop *)new wxEventLoop();
29504 wxPyEndAllowThreads(__tstate);
29505 if (PyErr_Occurred()) SWIG_fail;
29506 }
29507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29508 return resultobj;
29509 fail:
29510 return NULL;
29511 }
29512
29513
29514 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29515 PyObject *resultobj = 0;
29516 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 PyObject *swig_obj[1] ;
29520
29521 if (!args) SWIG_fail;
29522 swig_obj[0] = args;
29523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29524 if (!SWIG_IsOK(res1)) {
29525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29526 }
29527 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 delete arg1;
29531
29532 wxPyEndAllowThreads(__tstate);
29533 if (PyErr_Occurred()) SWIG_fail;
29534 }
29535 resultobj = SWIG_Py_Void();
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29543 PyObject *resultobj = 0;
29544 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29545 int result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29555 }
29556 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (int)(arg1)->Run();
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 resultobj = SWIG_From_int(static_cast< int >(result));
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29571 PyObject *resultobj = 0;
29572 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29573 int arg2 = (int) 0 ;
29574 void *argp1 = 0 ;
29575 int res1 = 0 ;
29576 int val2 ;
29577 int ecode2 = 0 ;
29578 PyObject * obj0 = 0 ;
29579 PyObject * obj1 = 0 ;
29580 char * kwnames[] = {
29581 (char *) "self",(char *) "rc", NULL
29582 };
29583
29584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29586 if (!SWIG_IsOK(res1)) {
29587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29588 }
29589 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29590 if (obj1) {
29591 ecode2 = SWIG_AsVal_int(obj1, &val2);
29592 if (!SWIG_IsOK(ecode2)) {
29593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29594 }
29595 arg2 = static_cast< int >(val2);
29596 }
29597 {
29598 PyThreadState* __tstate = wxPyBeginAllowThreads();
29599 (arg1)->Exit(arg2);
29600 wxPyEndAllowThreads(__tstate);
29601 if (PyErr_Occurred()) SWIG_fail;
29602 }
29603 resultobj = SWIG_Py_Void();
29604 return resultobj;
29605 fail:
29606 return NULL;
29607 }
29608
29609
29610 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29611 PyObject *resultobj = 0;
29612 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29613 bool result;
29614 void *argp1 = 0 ;
29615 int res1 = 0 ;
29616 PyObject *swig_obj[1] ;
29617
29618 if (!args) SWIG_fail;
29619 swig_obj[0] = args;
29620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29621 if (!SWIG_IsOK(res1)) {
29622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29623 }
29624 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29625 {
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = (bool)((wxEventLoop const *)arg1)->Pending();
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 {
29632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29633 }
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29641 PyObject *resultobj = 0;
29642 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29643 bool result;
29644 void *argp1 = 0 ;
29645 int res1 = 0 ;
29646 PyObject *swig_obj[1] ;
29647
29648 if (!args) SWIG_fail;
29649 swig_obj[0] = args;
29650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29651 if (!SWIG_IsOK(res1)) {
29652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29653 }
29654 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 result = (bool)(arg1)->Dispatch();
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29663 }
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29671 PyObject *resultobj = 0;
29672 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29673 bool result;
29674 void *argp1 = 0 ;
29675 int res1 = 0 ;
29676 PyObject *swig_obj[1] ;
29677
29678 if (!args) SWIG_fail;
29679 swig_obj[0] = args;
29680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29681 if (!SWIG_IsOK(res1)) {
29682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29683 }
29684 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29685 {
29686 PyThreadState* __tstate = wxPyBeginAllowThreads();
29687 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29688 wxPyEndAllowThreads(__tstate);
29689 if (PyErr_Occurred()) SWIG_fail;
29690 }
29691 {
29692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29693 }
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 PyObject *resultobj = 0;
29702 wxEventLoop *result = 0 ;
29703
29704 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (wxEventLoop *)wxEventLoop::GetActive();
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29712 return resultobj;
29713 fail:
29714 return NULL;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj = 0;
29720 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29721 void *argp1 = 0 ;
29722 int res1 = 0 ;
29723 PyObject * obj0 = 0 ;
29724 char * kwnames[] = {
29725 (char *) "loop", NULL
29726 };
29727
29728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29732 }
29733 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 wxEventLoop::SetActive(arg1);
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = SWIG_Py_Void();
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29748 PyObject *obj;
29749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29750 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29751 return SWIG_Py_Void();
29752 }
29753
29754 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 return SWIG_Python_InitShadowInstance(args);
29756 }
29757
29758 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29761 wxEventLoopActivator *result = 0 ;
29762 void *argp1 = 0 ;
29763 int res1 = 0 ;
29764 PyObject * obj0 = 0 ;
29765 char * kwnames[] = {
29766 (char *) "evtLoop", NULL
29767 };
29768
29769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29773 }
29774 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29789 PyObject *resultobj = 0;
29790 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29791 void *argp1 = 0 ;
29792 int res1 = 0 ;
29793 PyObject *swig_obj[1] ;
29794
29795 if (!args) SWIG_fail;
29796 swig_obj[0] = args;
29797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29798 if (!SWIG_IsOK(res1)) {
29799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29800 }
29801 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 delete arg1;
29805
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 resultobj = SWIG_Py_Void();
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29817 PyObject *obj;
29818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29819 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29820 return SWIG_Py_Void();
29821 }
29822
29823 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29824 return SWIG_Python_InitShadowInstance(args);
29825 }
29826
29827 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29828 PyObject *resultobj = 0;
29829 int arg1 = (int) 0 ;
29830 int arg2 = (int) 0 ;
29831 int arg3 = (int) 0 ;
29832 wxAcceleratorEntry *result = 0 ;
29833 int val1 ;
29834 int ecode1 = 0 ;
29835 int val2 ;
29836 int ecode2 = 0 ;
29837 int val3 ;
29838 int ecode3 = 0 ;
29839 PyObject * obj0 = 0 ;
29840 PyObject * obj1 = 0 ;
29841 PyObject * obj2 = 0 ;
29842 char * kwnames[] = {
29843 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29844 };
29845
29846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29847 if (obj0) {
29848 ecode1 = SWIG_AsVal_int(obj0, &val1);
29849 if (!SWIG_IsOK(ecode1)) {
29850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29851 }
29852 arg1 = static_cast< int >(val1);
29853 }
29854 if (obj1) {
29855 ecode2 = SWIG_AsVal_int(obj1, &val2);
29856 if (!SWIG_IsOK(ecode2)) {
29857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29858 }
29859 arg2 = static_cast< int >(val2);
29860 }
29861 if (obj2) {
29862 ecode3 = SWIG_AsVal_int(obj2, &val3);
29863 if (!SWIG_IsOK(ecode3)) {
29864 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29865 }
29866 arg3 = static_cast< int >(val3);
29867 }
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *resultobj = 0;
29883 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29884 void *argp1 = 0 ;
29885 int res1 = 0 ;
29886 PyObject *swig_obj[1] ;
29887
29888 if (!args) SWIG_fail;
29889 swig_obj[0] = args;
29890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29891 if (!SWIG_IsOK(res1)) {
29892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29893 }
29894 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 delete arg1;
29898
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_Py_Void();
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29910 PyObject *resultobj = 0;
29911 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29912 int arg2 ;
29913 int arg3 ;
29914 int arg4 ;
29915 void *argp1 = 0 ;
29916 int res1 = 0 ;
29917 int val2 ;
29918 int ecode2 = 0 ;
29919 int val3 ;
29920 int ecode3 = 0 ;
29921 int val4 ;
29922 int ecode4 = 0 ;
29923 PyObject * obj0 = 0 ;
29924 PyObject * obj1 = 0 ;
29925 PyObject * obj2 = 0 ;
29926 PyObject * obj3 = 0 ;
29927 char * kwnames[] = {
29928 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29929 };
29930
29931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29933 if (!SWIG_IsOK(res1)) {
29934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29935 }
29936 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29937 ecode2 = SWIG_AsVal_int(obj1, &val2);
29938 if (!SWIG_IsOK(ecode2)) {
29939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29940 }
29941 arg2 = static_cast< int >(val2);
29942 ecode3 = SWIG_AsVal_int(obj2, &val3);
29943 if (!SWIG_IsOK(ecode3)) {
29944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29945 }
29946 arg3 = static_cast< int >(val3);
29947 ecode4 = SWIG_AsVal_int(obj3, &val4);
29948 if (!SWIG_IsOK(ecode4)) {
29949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29950 }
29951 arg4 = static_cast< int >(val4);
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->Set(arg2,arg3,arg4);
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 resultobj = SWIG_Py_Void();
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj = 0;
29967 wxString *arg1 = 0 ;
29968 wxAcceleratorEntry *result = 0 ;
29969 bool temp1 = false ;
29970 PyObject * obj0 = 0 ;
29971 char * kwnames[] = {
29972 (char *) "str", NULL
29973 };
29974
29975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29976 {
29977 arg1 = wxString_in_helper(obj0);
29978 if (arg1 == NULL) SWIG_fail;
29979 temp1 = true;
29980 }
29981 {
29982 PyThreadState* __tstate = wxPyBeginAllowThreads();
29983 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29984 wxPyEndAllowThreads(__tstate);
29985 if (PyErr_Occurred()) SWIG_fail;
29986 }
29987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29988 {
29989 if (temp1)
29990 delete arg1;
29991 }
29992 return resultobj;
29993 fail:
29994 {
29995 if (temp1)
29996 delete arg1;
29997 }
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 PyObject *resultobj = 0;
30004 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30005 int result;
30006 void *argp1 = 0 ;
30007 int res1 = 0 ;
30008 PyObject *swig_obj[1] ;
30009
30010 if (!args) SWIG_fail;
30011 swig_obj[0] = args;
30012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30013 if (!SWIG_IsOK(res1)) {
30014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30015 }
30016 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30017 {
30018 PyThreadState* __tstate = wxPyBeginAllowThreads();
30019 result = (int)(arg1)->GetFlags();
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 resultobj = SWIG_From_int(static_cast< int >(result));
30024 return resultobj;
30025 fail:
30026 return NULL;
30027 }
30028
30029
30030 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30031 PyObject *resultobj = 0;
30032 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30033 int result;
30034 void *argp1 = 0 ;
30035 int res1 = 0 ;
30036 PyObject *swig_obj[1] ;
30037
30038 if (!args) SWIG_fail;
30039 swig_obj[0] = args;
30040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30041 if (!SWIG_IsOK(res1)) {
30042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30043 }
30044 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (int)(arg1)->GetKeyCode();
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 resultobj = SWIG_From_int(static_cast< int >(result));
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30059 PyObject *resultobj = 0;
30060 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30061 int result;
30062 void *argp1 = 0 ;
30063 int res1 = 0 ;
30064 PyObject *swig_obj[1] ;
30065
30066 if (!args) SWIG_fail;
30067 swig_obj[0] = args;
30068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30069 if (!SWIG_IsOK(res1)) {
30070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30071 }
30072 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30073 {
30074 PyThreadState* __tstate = wxPyBeginAllowThreads();
30075 result = (int)(arg1)->GetCommand();
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 resultobj = SWIG_From_int(static_cast< int >(result));
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30087 PyObject *resultobj = 0;
30088 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30089 bool result;
30090 void *argp1 = 0 ;
30091 int res1 = 0 ;
30092 PyObject *swig_obj[1] ;
30093
30094 if (!args) SWIG_fail;
30095 swig_obj[0] = args;
30096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30097 if (!SWIG_IsOK(res1)) {
30098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30099 }
30100 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 {
30108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30117 PyObject *resultobj = 0;
30118 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30119 wxString result;
30120 void *argp1 = 0 ;
30121 int res1 = 0 ;
30122 PyObject *swig_obj[1] ;
30123
30124 if (!args) SWIG_fail;
30125 swig_obj[0] = args;
30126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30127 if (!SWIG_IsOK(res1)) {
30128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
30129 }
30130 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30131 {
30132 PyThreadState* __tstate = wxPyBeginAllowThreads();
30133 result = ((wxAcceleratorEntry const *)arg1)->ToString();
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 {
30138 #if wxUSE_UNICODE
30139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30140 #else
30141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30142 #endif
30143 }
30144 return resultobj;
30145 fail:
30146 return NULL;
30147 }
30148
30149
30150 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30151 PyObject *resultobj = 0;
30152 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
30153 wxString *arg2 = 0 ;
30154 bool result;
30155 void *argp1 = 0 ;
30156 int res1 = 0 ;
30157 bool temp2 = false ;
30158 PyObject * obj0 = 0 ;
30159 PyObject * obj1 = 0 ;
30160 char * kwnames[] = {
30161 (char *) "self",(char *) "str", NULL
30162 };
30163
30164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
30165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
30168 }
30169 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
30170 {
30171 arg2 = wxString_in_helper(obj1);
30172 if (arg2 == NULL) SWIG_fail;
30173 temp2 = true;
30174 }
30175 {
30176 PyThreadState* __tstate = wxPyBeginAllowThreads();
30177 result = (bool)(arg1)->FromString((wxString const &)*arg2);
30178 wxPyEndAllowThreads(__tstate);
30179 if (PyErr_Occurred()) SWIG_fail;
30180 }
30181 {
30182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30183 }
30184 {
30185 if (temp2)
30186 delete arg2;
30187 }
30188 return resultobj;
30189 fail:
30190 {
30191 if (temp2)
30192 delete arg2;
30193 }
30194 return NULL;
30195 }
30196
30197
30198 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30199 PyObject *obj;
30200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30201 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
30202 return SWIG_Py_Void();
30203 }
30204
30205 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30206 return SWIG_Python_InitShadowInstance(args);
30207 }
30208
30209 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30210 PyObject *resultobj = 0;
30211 int arg1 ;
30212 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
30213 wxAcceleratorTable *result = 0 ;
30214 PyObject * obj0 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "n", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
30220 {
30221 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
30222 if (arg2) arg1 = PyList_Size(obj0);
30223 else arg1 = 0;
30224 }
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
30228 wxPyEndAllowThreads(__tstate);
30229 if (PyErr_Occurred()) SWIG_fail;
30230 }
30231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
30232 return resultobj;
30233 fail:
30234 return NULL;
30235 }
30236
30237
30238 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30239 PyObject *resultobj = 0;
30240 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30241 void *argp1 = 0 ;
30242 int res1 = 0 ;
30243 PyObject *swig_obj[1] ;
30244
30245 if (!args) SWIG_fail;
30246 swig_obj[0] = args;
30247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
30248 if (!SWIG_IsOK(res1)) {
30249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
30250 }
30251 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30252 {
30253 PyThreadState* __tstate = wxPyBeginAllowThreads();
30254 delete arg1;
30255
30256 wxPyEndAllowThreads(__tstate);
30257 if (PyErr_Occurred()) SWIG_fail;
30258 }
30259 resultobj = SWIG_Py_Void();
30260 return resultobj;
30261 fail:
30262 return NULL;
30263 }
30264
30265
30266 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30267 PyObject *resultobj = 0;
30268 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
30269 bool result;
30270 void *argp1 = 0 ;
30271 int res1 = 0 ;
30272 PyObject *swig_obj[1] ;
30273
30274 if (!args) SWIG_fail;
30275 swig_obj[0] = args;
30276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
30277 if (!SWIG_IsOK(res1)) {
30278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
30279 }
30280 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
30281 {
30282 PyThreadState* __tstate = wxPyBeginAllowThreads();
30283 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
30284 wxPyEndAllowThreads(__tstate);
30285 if (PyErr_Occurred()) SWIG_fail;
30286 }
30287 {
30288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30289 }
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 PyObject *obj;
30298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30299 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
30300 return SWIG_Py_Void();
30301 }
30302
30303 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30304 return SWIG_Python_InitShadowInstance(args);
30305 }
30306
30307 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
30308 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
30309 return 1;
30310 }
30311
30312
30313 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
30314 PyObject *pyobj = 0;
30315
30316 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
30317 return pyobj;
30318 }
30319
30320
30321 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30322 PyObject *resultobj = 0;
30323 wxString *arg1 = 0 ;
30324 wxAcceleratorEntry *result = 0 ;
30325 bool temp1 = false ;
30326 PyObject * obj0 = 0 ;
30327 char * kwnames[] = {
30328 (char *) "label", NULL
30329 };
30330
30331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
30332 {
30333 arg1 = wxString_in_helper(obj0);
30334 if (arg1 == NULL) SWIG_fail;
30335 temp1 = true;
30336 }
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
30344 {
30345 if (temp1)
30346 delete arg1;
30347 }
30348 return resultobj;
30349 fail:
30350 {
30351 if (temp1)
30352 delete arg1;
30353 }
30354 return NULL;
30355 }
30356
30357
30358 SWIGINTERN int PanelNameStr_set(PyObject *) {
30359 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
30360 return 1;
30361 }
30362
30363
30364 SWIGINTERN PyObject *PanelNameStr_get(void) {
30365 PyObject *pyobj = 0;
30366
30367 {
30368 #if wxUSE_UNICODE
30369 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30370 #else
30371 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
30372 #endif
30373 }
30374 return pyobj;
30375 }
30376
30377
30378 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30379 PyObject *resultobj = 0;
30380 wxVisualAttributes *result = 0 ;
30381
30382 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = (wxVisualAttributes *)new_wxVisualAttributes();
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30397 PyObject *resultobj = 0;
30398 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30399 void *argp1 = 0 ;
30400 int res1 = 0 ;
30401 PyObject *swig_obj[1] ;
30402
30403 if (!args) SWIG_fail;
30404 swig_obj[0] = args;
30405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30408 }
30409 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 delete_wxVisualAttributes(arg1);
30413
30414 wxPyEndAllowThreads(__tstate);
30415 if (PyErr_Occurred()) SWIG_fail;
30416 }
30417 resultobj = SWIG_Py_Void();
30418 return resultobj;
30419 fail:
30420 return NULL;
30421 }
30422
30423
30424 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30425 PyObject *resultobj = 0;
30426 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30427 wxFont *arg2 = (wxFont *) 0 ;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 void *argp2 = 0 ;
30431 int res2 = 0 ;
30432 PyObject *swig_obj[2] ;
30433
30434 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
30435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30436 if (!SWIG_IsOK(res1)) {
30437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30438 }
30439 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30440 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
30441 if (!SWIG_IsOK(res2)) {
30442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
30443 }
30444 arg2 = reinterpret_cast< wxFont * >(argp2);
30445 if (arg1) (arg1)->font = *arg2;
30446
30447 resultobj = SWIG_Py_Void();
30448 return resultobj;
30449 fail:
30450 return NULL;
30451 }
30452
30453
30454 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30455 PyObject *resultobj = 0;
30456 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30457 wxFont *result = 0 ;
30458 void *argp1 = 0 ;
30459 int res1 = 0 ;
30460 PyObject *swig_obj[1] ;
30461
30462 if (!args) SWIG_fail;
30463 swig_obj[0] = args;
30464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30465 if (!SWIG_IsOK(res1)) {
30466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30467 }
30468 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30469 result = (wxFont *)& ((arg1)->font);
30470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30480 wxColour *arg2 = (wxColour *) 0 ;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 void *argp2 = 0 ;
30484 int res2 = 0 ;
30485 PyObject *swig_obj[2] ;
30486
30487 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30491 }
30492 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30493 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30494 if (!SWIG_IsOK(res2)) {
30495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30496 }
30497 arg2 = reinterpret_cast< wxColour * >(argp2);
30498 if (arg1) (arg1)->colFg = *arg2;
30499
30500 resultobj = SWIG_Py_Void();
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30508 PyObject *resultobj = 0;
30509 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30510 wxColour *result = 0 ;
30511 void *argp1 = 0 ;
30512 int res1 = 0 ;
30513 PyObject *swig_obj[1] ;
30514
30515 if (!args) SWIG_fail;
30516 swig_obj[0] = args;
30517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30518 if (!SWIG_IsOK(res1)) {
30519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30520 }
30521 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30522 result = (wxColour *)& ((arg1)->colFg);
30523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30524 return resultobj;
30525 fail:
30526 return NULL;
30527 }
30528
30529
30530 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30531 PyObject *resultobj = 0;
30532 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30533 wxColour *arg2 = (wxColour *) 0 ;
30534 void *argp1 = 0 ;
30535 int res1 = 0 ;
30536 void *argp2 = 0 ;
30537 int res2 = 0 ;
30538 PyObject *swig_obj[2] ;
30539
30540 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30542 if (!SWIG_IsOK(res1)) {
30543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30544 }
30545 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30546 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30547 if (!SWIG_IsOK(res2)) {
30548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30549 }
30550 arg2 = reinterpret_cast< wxColour * >(argp2);
30551 if (arg1) (arg1)->colBg = *arg2;
30552
30553 resultobj = SWIG_Py_Void();
30554 return resultobj;
30555 fail:
30556 return NULL;
30557 }
30558
30559
30560 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30561 PyObject *resultobj = 0;
30562 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30563 wxColour *result = 0 ;
30564 void *argp1 = 0 ;
30565 int res1 = 0 ;
30566 PyObject *swig_obj[1] ;
30567
30568 if (!args) SWIG_fail;
30569 swig_obj[0] = args;
30570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30571 if (!SWIG_IsOK(res1)) {
30572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30573 }
30574 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30575 result = (wxColour *)& ((arg1)->colBg);
30576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *obj;
30585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30586 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30587 return SWIG_Py_Void();
30588 }
30589
30590 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30591 return SWIG_Python_InitShadowInstance(args);
30592 }
30593
30594 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30595 PyObject *resultobj = 0;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 int arg2 = (int) (int)-1 ;
30598 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30599 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30600 wxSize const &arg4_defvalue = wxDefaultSize ;
30601 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30602 long arg5 = (long) 0 ;
30603 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30604 wxString *arg6 = (wxString *) &arg6_defvalue ;
30605 wxWindow *result = 0 ;
30606 void *argp1 = 0 ;
30607 int res1 = 0 ;
30608 int val2 ;
30609 int ecode2 = 0 ;
30610 wxPoint temp3 ;
30611 wxSize temp4 ;
30612 long val5 ;
30613 int ecode5 = 0 ;
30614 bool temp6 = false ;
30615 PyObject * obj0 = 0 ;
30616 PyObject * obj1 = 0 ;
30617 PyObject * obj2 = 0 ;
30618 PyObject * obj3 = 0 ;
30619 PyObject * obj4 = 0 ;
30620 PyObject * obj5 = 0 ;
30621 char * kwnames[] = {
30622 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30623 };
30624
30625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30627 if (!SWIG_IsOK(res1)) {
30628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30629 }
30630 arg1 = reinterpret_cast< wxWindow * >(argp1);
30631 if (obj1) {
30632 ecode2 = SWIG_AsVal_int(obj1, &val2);
30633 if (!SWIG_IsOK(ecode2)) {
30634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30635 }
30636 arg2 = static_cast< int >(val2);
30637 }
30638 if (obj2) {
30639 {
30640 arg3 = &temp3;
30641 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30642 }
30643 }
30644 if (obj3) {
30645 {
30646 arg4 = &temp4;
30647 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30648 }
30649 }
30650 if (obj4) {
30651 ecode5 = SWIG_AsVal_long(obj4, &val5);
30652 if (!SWIG_IsOK(ecode5)) {
30653 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30654 }
30655 arg5 = static_cast< long >(val5);
30656 }
30657 if (obj5) {
30658 {
30659 arg6 = wxString_in_helper(obj5);
30660 if (arg6 == NULL) SWIG_fail;
30661 temp6 = true;
30662 }
30663 }
30664 {
30665 if (!wxPyCheckForApp()) SWIG_fail;
30666 PyThreadState* __tstate = wxPyBeginAllowThreads();
30667 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30672 {
30673 if (temp6)
30674 delete arg6;
30675 }
30676 return resultobj;
30677 fail:
30678 {
30679 if (temp6)
30680 delete arg6;
30681 }
30682 return NULL;
30683 }
30684
30685
30686 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30687 PyObject *resultobj = 0;
30688 wxWindow *result = 0 ;
30689
30690 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30691 {
30692 if (!wxPyCheckForApp()) SWIG_fail;
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (wxWindow *)new wxWindow();
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 wxWindow *arg2 = (wxWindow *) 0 ;
30709 int arg3 = (int) (int)-1 ;
30710 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30711 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30712 wxSize const &arg5_defvalue = wxDefaultSize ;
30713 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30714 long arg6 = (long) 0 ;
30715 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30716 wxString *arg7 = (wxString *) &arg7_defvalue ;
30717 bool result;
30718 void *argp1 = 0 ;
30719 int res1 = 0 ;
30720 void *argp2 = 0 ;
30721 int res2 = 0 ;
30722 int val3 ;
30723 int ecode3 = 0 ;
30724 wxPoint temp4 ;
30725 wxSize temp5 ;
30726 long val6 ;
30727 int ecode6 = 0 ;
30728 bool temp7 = false ;
30729 PyObject * obj0 = 0 ;
30730 PyObject * obj1 = 0 ;
30731 PyObject * obj2 = 0 ;
30732 PyObject * obj3 = 0 ;
30733 PyObject * obj4 = 0 ;
30734 PyObject * obj5 = 0 ;
30735 PyObject * obj6 = 0 ;
30736 char * kwnames[] = {
30737 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30738 };
30739
30740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30742 if (!SWIG_IsOK(res1)) {
30743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30744 }
30745 arg1 = reinterpret_cast< wxWindow * >(argp1);
30746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30747 if (!SWIG_IsOK(res2)) {
30748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30749 }
30750 arg2 = reinterpret_cast< wxWindow * >(argp2);
30751 if (obj2) {
30752 ecode3 = SWIG_AsVal_int(obj2, &val3);
30753 if (!SWIG_IsOK(ecode3)) {
30754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30755 }
30756 arg3 = static_cast< int >(val3);
30757 }
30758 if (obj3) {
30759 {
30760 arg4 = &temp4;
30761 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30762 }
30763 }
30764 if (obj4) {
30765 {
30766 arg5 = &temp5;
30767 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30768 }
30769 }
30770 if (obj5) {
30771 ecode6 = SWIG_AsVal_long(obj5, &val6);
30772 if (!SWIG_IsOK(ecode6)) {
30773 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30774 }
30775 arg6 = static_cast< long >(val6);
30776 }
30777 if (obj6) {
30778 {
30779 arg7 = wxString_in_helper(obj6);
30780 if (arg7 == NULL) SWIG_fail;
30781 temp7 = true;
30782 }
30783 }
30784 {
30785 PyThreadState* __tstate = wxPyBeginAllowThreads();
30786 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30787 wxPyEndAllowThreads(__tstate);
30788 if (PyErr_Occurred()) SWIG_fail;
30789 }
30790 {
30791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30792 }
30793 {
30794 if (temp7)
30795 delete arg7;
30796 }
30797 return resultobj;
30798 fail:
30799 {
30800 if (temp7)
30801 delete arg7;
30802 }
30803 return NULL;
30804 }
30805
30806
30807 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30808 PyObject *resultobj = 0;
30809 wxWindow *arg1 = (wxWindow *) 0 ;
30810 bool arg2 = (bool) false ;
30811 bool result;
30812 void *argp1 = 0 ;
30813 int res1 = 0 ;
30814 bool val2 ;
30815 int ecode2 = 0 ;
30816 PyObject * obj0 = 0 ;
30817 PyObject * obj1 = 0 ;
30818 char * kwnames[] = {
30819 (char *) "self",(char *) "force", NULL
30820 };
30821
30822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30824 if (!SWIG_IsOK(res1)) {
30825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30826 }
30827 arg1 = reinterpret_cast< wxWindow * >(argp1);
30828 if (obj1) {
30829 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30830 if (!SWIG_IsOK(ecode2)) {
30831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30832 }
30833 arg2 = static_cast< bool >(val2);
30834 }
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (bool)(arg1)->Close(arg2);
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30843 }
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 bool result;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 PyObject *swig_obj[1] ;
30857
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = (bool)(arg1)->Destroy();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 {
30872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30873 }
30874 return resultobj;
30875 fail:
30876 return NULL;
30877 }
30878
30879
30880 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30881 PyObject *resultobj = 0;
30882 wxWindow *arg1 = (wxWindow *) 0 ;
30883 bool result;
30884 void *argp1 = 0 ;
30885 int res1 = 0 ;
30886 PyObject *swig_obj[1] ;
30887
30888 if (!args) SWIG_fail;
30889 swig_obj[0] = args;
30890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30891 if (!SWIG_IsOK(res1)) {
30892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30893 }
30894 arg1 = reinterpret_cast< wxWindow * >(argp1);
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 result = (bool)(arg1)->DestroyChildren();
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 {
30902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 bool result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 {
30932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = 0;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxString *arg2 = 0 ;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 bool temp2 = false ;
30947 PyObject * obj0 = 0 ;
30948 PyObject * obj1 = 0 ;
30949 char * kwnames[] = {
30950 (char *) "self",(char *) "label", NULL
30951 };
30952
30953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30955 if (!SWIG_IsOK(res1)) {
30956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30957 }
30958 arg1 = reinterpret_cast< wxWindow * >(argp1);
30959 {
30960 arg2 = wxString_in_helper(obj1);
30961 if (arg2 == NULL) SWIG_fail;
30962 temp2 = true;
30963 }
30964 {
30965 PyThreadState* __tstate = wxPyBeginAllowThreads();
30966 (arg1)->SetLabel((wxString const &)*arg2);
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 resultobj = SWIG_Py_Void();
30971 {
30972 if (temp2)
30973 delete arg2;
30974 }
30975 return resultobj;
30976 fail:
30977 {
30978 if (temp2)
30979 delete arg2;
30980 }
30981 return NULL;
30982 }
30983
30984
30985 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30986 PyObject *resultobj = 0;
30987 wxWindow *arg1 = (wxWindow *) 0 ;
30988 wxString result;
30989 void *argp1 = 0 ;
30990 int res1 = 0 ;
30991 PyObject *swig_obj[1] ;
30992
30993 if (!args) SWIG_fail;
30994 swig_obj[0] = args;
30995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30996 if (!SWIG_IsOK(res1)) {
30997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30998 }
30999 arg1 = reinterpret_cast< wxWindow * >(argp1);
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = ((wxWindow const *)arg1)->GetLabel();
31003 wxPyEndAllowThreads(__tstate);
31004 if (PyErr_Occurred()) SWIG_fail;
31005 }
31006 {
31007 #if wxUSE_UNICODE
31008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31009 #else
31010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31011 #endif
31012 }
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31020 PyObject *resultobj = 0;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 wxString *arg2 = 0 ;
31023 void *argp1 = 0 ;
31024 int res1 = 0 ;
31025 bool temp2 = false ;
31026 PyObject * obj0 = 0 ;
31027 PyObject * obj1 = 0 ;
31028 char * kwnames[] = {
31029 (char *) "self",(char *) "name", NULL
31030 };
31031
31032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
31033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31034 if (!SWIG_IsOK(res1)) {
31035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
31036 }
31037 arg1 = reinterpret_cast< wxWindow * >(argp1);
31038 {
31039 arg2 = wxString_in_helper(obj1);
31040 if (arg2 == NULL) SWIG_fail;
31041 temp2 = true;
31042 }
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 (arg1)->SetName((wxString const &)*arg2);
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_Py_Void();
31050 {
31051 if (temp2)
31052 delete arg2;
31053 }
31054 return resultobj;
31055 fail:
31056 {
31057 if (temp2)
31058 delete arg2;
31059 }
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31065 PyObject *resultobj = 0;
31066 wxWindow *arg1 = (wxWindow *) 0 ;
31067 wxString result;
31068 void *argp1 = 0 ;
31069 int res1 = 0 ;
31070 PyObject *swig_obj[1] ;
31071
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
31077 }
31078 arg1 = reinterpret_cast< wxWindow * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = ((wxWindow const *)arg1)->GetName();
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 {
31086 #if wxUSE_UNICODE
31087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31088 #else
31089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31090 #endif
31091 }
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj = 0;
31100 wxWindow *arg1 = (wxWindow *) 0 ;
31101 wxWindowVariant arg2 ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 int val2 ;
31105 int ecode2 = 0 ;
31106 PyObject * obj0 = 0 ;
31107 PyObject * obj1 = 0 ;
31108 char * kwnames[] = {
31109 (char *) "self",(char *) "variant", NULL
31110 };
31111
31112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
31113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 ecode2 = SWIG_AsVal_int(obj1, &val2);
31119 if (!SWIG_IsOK(ecode2)) {
31120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
31121 }
31122 arg2 = static_cast< wxWindowVariant >(val2);
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 (arg1)->SetWindowVariant(arg2);
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 resultobj = SWIG_Py_Void();
31130 return resultobj;
31131 fail:
31132 return NULL;
31133 }
31134
31135
31136 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31137 PyObject *resultobj = 0;
31138 wxWindow *arg1 = (wxWindow *) 0 ;
31139 wxWindowVariant result;
31140 void *argp1 = 0 ;
31141 int res1 = 0 ;
31142 PyObject *swig_obj[1] ;
31143
31144 if (!args) SWIG_fail;
31145 swig_obj[0] = args;
31146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31147 if (!SWIG_IsOK(res1)) {
31148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
31149 }
31150 arg1 = reinterpret_cast< wxWindow * >(argp1);
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_From_int(static_cast< int >(result));
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = 0;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 int arg2 ;
31168 void *argp1 = 0 ;
31169 int res1 = 0 ;
31170 int val2 ;
31171 int ecode2 = 0 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 char * kwnames[] = {
31175 (char *) "self",(char *) "winid", NULL
31176 };
31177
31178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
31179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31180 if (!SWIG_IsOK(res1)) {
31181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
31182 }
31183 arg1 = reinterpret_cast< wxWindow * >(argp1);
31184 ecode2 = SWIG_AsVal_int(obj1, &val2);
31185 if (!SWIG_IsOK(ecode2)) {
31186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
31187 }
31188 arg2 = static_cast< int >(val2);
31189 {
31190 PyThreadState* __tstate = wxPyBeginAllowThreads();
31191 (arg1)->SetId(arg2);
31192 wxPyEndAllowThreads(__tstate);
31193 if (PyErr_Occurred()) SWIG_fail;
31194 }
31195 resultobj = SWIG_Py_Void();
31196 return resultobj;
31197 fail:
31198 return NULL;
31199 }
31200
31201
31202 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31203 PyObject *resultobj = 0;
31204 wxWindow *arg1 = (wxWindow *) 0 ;
31205 int result;
31206 void *argp1 = 0 ;
31207 int res1 = 0 ;
31208 PyObject *swig_obj[1] ;
31209
31210 if (!args) SWIG_fail;
31211 swig_obj[0] = args;
31212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
31215 }
31216 arg1 = reinterpret_cast< wxWindow * >(argp1);
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 result = (int)((wxWindow const *)arg1)->GetId();
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_From_int(static_cast< int >(result));
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 PyObject *resultobj = 0;
31232 int result;
31233
31234 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 result = (int)wxWindow::NewControlId();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_From_int(static_cast< int >(result));
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31249 PyObject *resultobj = 0;
31250 int arg1 ;
31251 int result;
31252 int val1 ;
31253 int ecode1 = 0 ;
31254 PyObject * obj0 = 0 ;
31255 char * kwnames[] = {
31256 (char *) "winid", NULL
31257 };
31258
31259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
31260 ecode1 = SWIG_AsVal_int(obj0, &val1);
31261 if (!SWIG_IsOK(ecode1)) {
31262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
31263 }
31264 arg1 = static_cast< int >(val1);
31265 {
31266 PyThreadState* __tstate = wxPyBeginAllowThreads();
31267 result = (int)wxWindow::NextControlId(arg1);
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 resultobj = SWIG_From_int(static_cast< int >(result));
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31279 PyObject *resultobj = 0;
31280 int arg1 ;
31281 int result;
31282 int val1 ;
31283 int ecode1 = 0 ;
31284 PyObject * obj0 = 0 ;
31285 char * kwnames[] = {
31286 (char *) "winid", NULL
31287 };
31288
31289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
31290 ecode1 = SWIG_AsVal_int(obj0, &val1);
31291 if (!SWIG_IsOK(ecode1)) {
31292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
31293 }
31294 arg1 = static_cast< int >(val1);
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = (int)wxWindow::PrevControlId(arg1);
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 resultobj = SWIG_From_int(static_cast< int >(result));
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31309 PyObject *resultobj = 0;
31310 wxWindow *arg1 = (wxWindow *) 0 ;
31311 wxLayoutDirection result;
31312 void *argp1 = 0 ;
31313 int res1 = 0 ;
31314 PyObject *swig_obj[1] ;
31315
31316 if (!args) SWIG_fail;
31317 swig_obj[0] = args;
31318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31319 if (!SWIG_IsOK(res1)) {
31320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31321 }
31322 arg1 = reinterpret_cast< wxWindow * >(argp1);
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 resultobj = SWIG_From_int(static_cast< int >(result));
31330 return resultobj;
31331 fail:
31332 return NULL;
31333 }
31334
31335
31336 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31337 PyObject *resultobj = 0;
31338 wxWindow *arg1 = (wxWindow *) 0 ;
31339 wxLayoutDirection arg2 ;
31340 void *argp1 = 0 ;
31341 int res1 = 0 ;
31342 int val2 ;
31343 int ecode2 = 0 ;
31344 PyObject * obj0 = 0 ;
31345 PyObject * obj1 = 0 ;
31346 char * kwnames[] = {
31347 (char *) "self",(char *) "dir", NULL
31348 };
31349
31350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
31351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31352 if (!SWIG_IsOK(res1)) {
31353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
31354 }
31355 arg1 = reinterpret_cast< wxWindow * >(argp1);
31356 ecode2 = SWIG_AsVal_int(obj1, &val2);
31357 if (!SWIG_IsOK(ecode2)) {
31358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
31359 }
31360 arg2 = static_cast< wxLayoutDirection >(val2);
31361 {
31362 PyThreadState* __tstate = wxPyBeginAllowThreads();
31363 (arg1)->SetLayoutDirection(arg2);
31364 wxPyEndAllowThreads(__tstate);
31365 if (PyErr_Occurred()) SWIG_fail;
31366 }
31367 resultobj = SWIG_Py_Void();
31368 return resultobj;
31369 fail:
31370 return NULL;
31371 }
31372
31373
31374 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31375 PyObject *resultobj = 0;
31376 wxWindow *arg1 = (wxWindow *) 0 ;
31377 int arg2 ;
31378 int arg3 ;
31379 int arg4 ;
31380 int result;
31381 void *argp1 = 0 ;
31382 int res1 = 0 ;
31383 int val2 ;
31384 int ecode2 = 0 ;
31385 int val3 ;
31386 int ecode3 = 0 ;
31387 int val4 ;
31388 int ecode4 = 0 ;
31389 PyObject * obj0 = 0 ;
31390 PyObject * obj1 = 0 ;
31391 PyObject * obj2 = 0 ;
31392 PyObject * obj3 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31399 if (!SWIG_IsOK(res1)) {
31400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
31401 }
31402 arg1 = reinterpret_cast< wxWindow * >(argp1);
31403 ecode2 = SWIG_AsVal_int(obj1, &val2);
31404 if (!SWIG_IsOK(ecode2)) {
31405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
31406 }
31407 arg2 = static_cast< int >(val2);
31408 ecode3 = SWIG_AsVal_int(obj2, &val3);
31409 if (!SWIG_IsOK(ecode3)) {
31410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
31411 }
31412 arg3 = static_cast< int >(val3);
31413 ecode4 = SWIG_AsVal_int(obj3, &val4);
31414 if (!SWIG_IsOK(ecode4)) {
31415 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
31416 }
31417 arg4 = static_cast< int >(val4);
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_From_int(static_cast< int >(result));
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj = 0;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 wxSize *arg2 = 0 ;
31435 void *argp1 = 0 ;
31436 int res1 = 0 ;
31437 wxSize temp2 ;
31438 PyObject * obj0 = 0 ;
31439 PyObject * obj1 = 0 ;
31440 char * kwnames[] = {
31441 (char *) "self",(char *) "size", NULL
31442 };
31443
31444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
31445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31446 if (!SWIG_IsOK(res1)) {
31447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31448 }
31449 arg1 = reinterpret_cast< wxWindow * >(argp1);
31450 {
31451 arg2 = &temp2;
31452 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31453 }
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 (arg1)->SetSize((wxSize const &)*arg2);
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 resultobj = SWIG_Py_Void();
31461 return resultobj;
31462 fail:
31463 return NULL;
31464 }
31465
31466
31467 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31468 PyObject *resultobj = 0;
31469 wxWindow *arg1 = (wxWindow *) 0 ;
31470 int arg2 ;
31471 int arg3 ;
31472 int arg4 ;
31473 int arg5 ;
31474 int arg6 = (int) wxSIZE_AUTO ;
31475 void *argp1 = 0 ;
31476 int res1 = 0 ;
31477 int val2 ;
31478 int ecode2 = 0 ;
31479 int val3 ;
31480 int ecode3 = 0 ;
31481 int val4 ;
31482 int ecode4 = 0 ;
31483 int val5 ;
31484 int ecode5 = 0 ;
31485 int val6 ;
31486 int ecode6 = 0 ;
31487 PyObject * obj0 = 0 ;
31488 PyObject * obj1 = 0 ;
31489 PyObject * obj2 = 0 ;
31490 PyObject * obj3 = 0 ;
31491 PyObject * obj4 = 0 ;
31492 PyObject * obj5 = 0 ;
31493 char * kwnames[] = {
31494 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31495 };
31496
31497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31499 if (!SWIG_IsOK(res1)) {
31500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31501 }
31502 arg1 = reinterpret_cast< wxWindow * >(argp1);
31503 ecode2 = SWIG_AsVal_int(obj1, &val2);
31504 if (!SWIG_IsOK(ecode2)) {
31505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31506 }
31507 arg2 = static_cast< int >(val2);
31508 ecode3 = SWIG_AsVal_int(obj2, &val3);
31509 if (!SWIG_IsOK(ecode3)) {
31510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31511 }
31512 arg3 = static_cast< int >(val3);
31513 ecode4 = SWIG_AsVal_int(obj3, &val4);
31514 if (!SWIG_IsOK(ecode4)) {
31515 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31516 }
31517 arg4 = static_cast< int >(val4);
31518 ecode5 = SWIG_AsVal_int(obj4, &val5);
31519 if (!SWIG_IsOK(ecode5)) {
31520 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31521 }
31522 arg5 = static_cast< int >(val5);
31523 if (obj5) {
31524 ecode6 = SWIG_AsVal_int(obj5, &val6);
31525 if (!SWIG_IsOK(ecode6)) {
31526 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31527 }
31528 arg6 = static_cast< int >(val6);
31529 }
31530 {
31531 PyThreadState* __tstate = wxPyBeginAllowThreads();
31532 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_Py_Void();
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31544 PyObject *resultobj = 0;
31545 wxWindow *arg1 = (wxWindow *) 0 ;
31546 wxRect *arg2 = 0 ;
31547 int arg3 = (int) wxSIZE_AUTO ;
31548 void *argp1 = 0 ;
31549 int res1 = 0 ;
31550 wxRect temp2 ;
31551 int val3 ;
31552 int ecode3 = 0 ;
31553 PyObject * obj0 = 0 ;
31554 PyObject * obj1 = 0 ;
31555 PyObject * obj2 = 0 ;
31556 char * kwnames[] = {
31557 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31558 };
31559
31560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31562 if (!SWIG_IsOK(res1)) {
31563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31564 }
31565 arg1 = reinterpret_cast< wxWindow * >(argp1);
31566 {
31567 arg2 = &temp2;
31568 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31569 }
31570 if (obj2) {
31571 ecode3 = SWIG_AsVal_int(obj2, &val3);
31572 if (!SWIG_IsOK(ecode3)) {
31573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31574 }
31575 arg3 = static_cast< int >(val3);
31576 }
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_Py_Void();
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 int arg2 ;
31594 int arg3 ;
31595 void *argp1 = 0 ;
31596 int res1 = 0 ;
31597 int val2 ;
31598 int ecode2 = 0 ;
31599 int val3 ;
31600 int ecode3 = 0 ;
31601 PyObject * obj0 = 0 ;
31602 PyObject * obj1 = 0 ;
31603 PyObject * obj2 = 0 ;
31604 char * kwnames[] = {
31605 (char *) "self",(char *) "width",(char *) "height", NULL
31606 };
31607
31608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31610 if (!SWIG_IsOK(res1)) {
31611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31612 }
31613 arg1 = reinterpret_cast< wxWindow * >(argp1);
31614 ecode2 = SWIG_AsVal_int(obj1, &val2);
31615 if (!SWIG_IsOK(ecode2)) {
31616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31617 }
31618 arg2 = static_cast< int >(val2);
31619 ecode3 = SWIG_AsVal_int(obj2, &val3);
31620 if (!SWIG_IsOK(ecode3)) {
31621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31622 }
31623 arg3 = static_cast< int >(val3);
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->SetSize(arg2,arg3);
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxWindow *arg1 = (wxWindow *) 0 ;
31640 wxPoint *arg2 = 0 ;
31641 int arg3 = (int) wxSIZE_USE_EXISTING ;
31642 void *argp1 = 0 ;
31643 int res1 = 0 ;
31644 wxPoint temp2 ;
31645 int val3 ;
31646 int ecode3 = 0 ;
31647 PyObject * obj0 = 0 ;
31648 PyObject * obj1 = 0 ;
31649 PyObject * obj2 = 0 ;
31650 char * kwnames[] = {
31651 (char *) "self",(char *) "pt",(char *) "flags", NULL
31652 };
31653
31654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31656 if (!SWIG_IsOK(res1)) {
31657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31658 }
31659 arg1 = reinterpret_cast< wxWindow * >(argp1);
31660 {
31661 arg2 = &temp2;
31662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31663 }
31664 if (obj2) {
31665 ecode3 = SWIG_AsVal_int(obj2, &val3);
31666 if (!SWIG_IsOK(ecode3)) {
31667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31668 }
31669 arg3 = static_cast< int >(val3);
31670 }
31671 {
31672 PyThreadState* __tstate = wxPyBeginAllowThreads();
31673 (arg1)->Move((wxPoint const &)*arg2,arg3);
31674 wxPyEndAllowThreads(__tstate);
31675 if (PyErr_Occurred()) SWIG_fail;
31676 }
31677 resultobj = SWIG_Py_Void();
31678 return resultobj;
31679 fail:
31680 return NULL;
31681 }
31682
31683
31684 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31685 PyObject *resultobj = 0;
31686 wxWindow *arg1 = (wxWindow *) 0 ;
31687 int arg2 ;
31688 int arg3 ;
31689 int arg4 = (int) wxSIZE_USE_EXISTING ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int val2 ;
31693 int ecode2 = 0 ;
31694 int val3 ;
31695 int ecode3 = 0 ;
31696 int val4 ;
31697 int ecode4 = 0 ;
31698 PyObject * obj0 = 0 ;
31699 PyObject * obj1 = 0 ;
31700 PyObject * obj2 = 0 ;
31701 PyObject * obj3 = 0 ;
31702 char * kwnames[] = {
31703 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31704 };
31705
31706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31708 if (!SWIG_IsOK(res1)) {
31709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31710 }
31711 arg1 = reinterpret_cast< wxWindow * >(argp1);
31712 ecode2 = SWIG_AsVal_int(obj1, &val2);
31713 if (!SWIG_IsOK(ecode2)) {
31714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31715 }
31716 arg2 = static_cast< int >(val2);
31717 ecode3 = SWIG_AsVal_int(obj2, &val3);
31718 if (!SWIG_IsOK(ecode3)) {
31719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31720 }
31721 arg3 = static_cast< int >(val3);
31722 if (obj3) {
31723 ecode4 = SWIG_AsVal_int(obj3, &val4);
31724 if (!SWIG_IsOK(ecode4)) {
31725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31726 }
31727 arg4 = static_cast< int >(val4);
31728 }
31729 {
31730 PyThreadState* __tstate = wxPyBeginAllowThreads();
31731 (arg1)->Move(arg2,arg3,arg4);
31732 wxPyEndAllowThreads(__tstate);
31733 if (PyErr_Occurred()) SWIG_fail;
31734 }
31735 resultobj = SWIG_Py_Void();
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31743 PyObject *resultobj = 0;
31744 wxWindow *arg1 = (wxWindow *) 0 ;
31745 wxSize const &arg2_defvalue = wxDefaultSize ;
31746 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31747 void *argp1 = 0 ;
31748 int res1 = 0 ;
31749 wxSize temp2 ;
31750 PyObject * obj0 = 0 ;
31751 PyObject * obj1 = 0 ;
31752 char * kwnames[] = {
31753 (char *) "self",(char *) "size", NULL
31754 };
31755
31756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31758 if (!SWIG_IsOK(res1)) {
31759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31760 }
31761 arg1 = reinterpret_cast< wxWindow * >(argp1);
31762 if (obj1) {
31763 {
31764 arg2 = &temp2;
31765 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31766 }
31767 }
31768 {
31769 PyThreadState* __tstate = wxPyBeginAllowThreads();
31770 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 resultobj = SWIG_Py_Void();
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31782 PyObject *resultobj = 0;
31783 wxWindow *arg1 = (wxWindow *) 0 ;
31784 void *argp1 = 0 ;
31785 int res1 = 0 ;
31786 PyObject *swig_obj[1] ;
31787
31788 if (!args) SWIG_fail;
31789 swig_obj[0] = args;
31790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31791 if (!SWIG_IsOK(res1)) {
31792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31793 }
31794 arg1 = reinterpret_cast< wxWindow * >(argp1);
31795 {
31796 PyThreadState* __tstate = wxPyBeginAllowThreads();
31797 (arg1)->Raise();
31798 wxPyEndAllowThreads(__tstate);
31799 if (PyErr_Occurred()) SWIG_fail;
31800 }
31801 resultobj = SWIG_Py_Void();
31802 return resultobj;
31803 fail:
31804 return NULL;
31805 }
31806
31807
31808 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31809 PyObject *resultobj = 0;
31810 wxWindow *arg1 = (wxWindow *) 0 ;
31811 void *argp1 = 0 ;
31812 int res1 = 0 ;
31813 PyObject *swig_obj[1] ;
31814
31815 if (!args) SWIG_fail;
31816 swig_obj[0] = args;
31817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31818 if (!SWIG_IsOK(res1)) {
31819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31820 }
31821 arg1 = reinterpret_cast< wxWindow * >(argp1);
31822 {
31823 PyThreadState* __tstate = wxPyBeginAllowThreads();
31824 (arg1)->Lower();
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj = 0;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 wxSize *arg2 = 0 ;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 wxSize temp2 ;
31842 PyObject * obj0 = 0 ;
31843 PyObject * obj1 = 0 ;
31844 char * kwnames[] = {
31845 (char *) "self",(char *) "size", NULL
31846 };
31847
31848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31850 if (!SWIG_IsOK(res1)) {
31851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31852 }
31853 arg1 = reinterpret_cast< wxWindow * >(argp1);
31854 {
31855 arg2 = &temp2;
31856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31857 }
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 (arg1)->SetClientSize((wxSize const &)*arg2);
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_Py_Void();
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31872 PyObject *resultobj = 0;
31873 wxWindow *arg1 = (wxWindow *) 0 ;
31874 int arg2 ;
31875 int arg3 ;
31876 void *argp1 = 0 ;
31877 int res1 = 0 ;
31878 int val2 ;
31879 int ecode2 = 0 ;
31880 int val3 ;
31881 int ecode3 = 0 ;
31882 PyObject * obj0 = 0 ;
31883 PyObject * obj1 = 0 ;
31884 PyObject * obj2 = 0 ;
31885 char * kwnames[] = {
31886 (char *) "self",(char *) "width",(char *) "height", NULL
31887 };
31888
31889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31893 }
31894 arg1 = reinterpret_cast< wxWindow * >(argp1);
31895 ecode2 = SWIG_AsVal_int(obj1, &val2);
31896 if (!SWIG_IsOK(ecode2)) {
31897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31898 }
31899 arg2 = static_cast< int >(val2);
31900 ecode3 = SWIG_AsVal_int(obj2, &val3);
31901 if (!SWIG_IsOK(ecode3)) {
31902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31903 }
31904 arg3 = static_cast< int >(val3);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->SetClientSize(arg2,arg3);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31919 PyObject *resultobj = 0;
31920 wxWindow *arg1 = (wxWindow *) 0 ;
31921 wxRect *arg2 = 0 ;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 wxRect temp2 ;
31925 PyObject * obj0 = 0 ;
31926 PyObject * obj1 = 0 ;
31927 char * kwnames[] = {
31928 (char *) "self",(char *) "rect", NULL
31929 };
31930
31931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31933 if (!SWIG_IsOK(res1)) {
31934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31935 }
31936 arg1 = reinterpret_cast< wxWindow * >(argp1);
31937 {
31938 arg2 = &temp2;
31939 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31940 }
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 (arg1)->SetClientSize((wxRect const &)*arg2);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *resultobj = 0;
31956 wxWindow *arg1 = (wxWindow *) 0 ;
31957 wxPoint result;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 PyObject *swig_obj[1] ;
31961
31962 if (!args) SWIG_fail;
31963 swig_obj[0] = args;
31964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31967 }
31968 arg1 = reinterpret_cast< wxWindow * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = ((wxWindow const *)arg1)->GetPosition();
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 int *arg2 = (int *) 0 ;
31986 int *arg3 = (int *) 0 ;
31987 void *argp1 = 0 ;
31988 int res1 = 0 ;
31989 int temp2 ;
31990 int res2 = SWIG_TMPOBJ ;
31991 int temp3 ;
31992 int res3 = SWIG_TMPOBJ ;
31993 PyObject *swig_obj[1] ;
31994
31995 arg2 = &temp2;
31996 arg3 = &temp3;
31997 if (!args) SWIG_fail;
31998 swig_obj[0] = args;
31999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32000 if (!SWIG_IsOK(res1)) {
32001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32002 }
32003 arg1 = reinterpret_cast< wxWindow * >(argp1);
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
32007 wxPyEndAllowThreads(__tstate);
32008 if (PyErr_Occurred()) SWIG_fail;
32009 }
32010 resultobj = SWIG_Py_Void();
32011 if (SWIG_IsTmpObj(res2)) {
32012 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32013 } else {
32014 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32015 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32016 }
32017 if (SWIG_IsTmpObj(res3)) {
32018 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32019 } else {
32020 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32021 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32022 }
32023 return resultobj;
32024 fail:
32025 return NULL;
32026 }
32027
32028
32029 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32030 PyObject *resultobj = 0;
32031 wxWindow *arg1 = (wxWindow *) 0 ;
32032 wxPoint result;
32033 void *argp1 = 0 ;
32034 int res1 = 0 ;
32035 PyObject *swig_obj[1] ;
32036
32037 if (!args) SWIG_fail;
32038 swig_obj[0] = args;
32039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32040 if (!SWIG_IsOK(res1)) {
32041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
32042 }
32043 arg1 = reinterpret_cast< wxWindow * >(argp1);
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = ((wxWindow const *)arg1)->GetScreenPosition();
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 PyObject *resultobj = 0;
32059 wxWindow *arg1 = (wxWindow *) 0 ;
32060 int *arg2 = (int *) 0 ;
32061 int *arg3 = (int *) 0 ;
32062 void *argp1 = 0 ;
32063 int res1 = 0 ;
32064 int temp2 ;
32065 int res2 = SWIG_TMPOBJ ;
32066 int temp3 ;
32067 int res3 = SWIG_TMPOBJ ;
32068 PyObject *swig_obj[1] ;
32069
32070 arg2 = &temp2;
32071 arg3 = &temp3;
32072 if (!args) SWIG_fail;
32073 swig_obj[0] = args;
32074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32075 if (!SWIG_IsOK(res1)) {
32076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32077 }
32078 arg1 = reinterpret_cast< wxWindow * >(argp1);
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
32082 wxPyEndAllowThreads(__tstate);
32083 if (PyErr_Occurred()) SWIG_fail;
32084 }
32085 resultobj = SWIG_Py_Void();
32086 if (SWIG_IsTmpObj(res2)) {
32087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32088 } else {
32089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32091 }
32092 if (SWIG_IsTmpObj(res3)) {
32093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32094 } else {
32095 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32097 }
32098 return resultobj;
32099 fail:
32100 return NULL;
32101 }
32102
32103
32104 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32105 PyObject *resultobj = 0;
32106 wxWindow *arg1 = (wxWindow *) 0 ;
32107 wxRect result;
32108 void *argp1 = 0 ;
32109 int res1 = 0 ;
32110 PyObject *swig_obj[1] ;
32111
32112 if (!args) SWIG_fail;
32113 swig_obj[0] = args;
32114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32115 if (!SWIG_IsOK(res1)) {
32116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32117 }
32118 arg1 = reinterpret_cast< wxWindow * >(argp1);
32119 {
32120 PyThreadState* __tstate = wxPyBeginAllowThreads();
32121 result = ((wxWindow const *)arg1)->GetScreenRect();
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 wxWindow *arg1 = (wxWindow *) 0 ;
32135 wxSize result;
32136 void *argp1 = 0 ;
32137 int res1 = 0 ;
32138 PyObject *swig_obj[1] ;
32139
32140 if (!args) SWIG_fail;
32141 swig_obj[0] = args;
32142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 {
32148 PyThreadState* __tstate = wxPyBeginAllowThreads();
32149 result = ((wxWindow const *)arg1)->GetSize();
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32154 return resultobj;
32155 fail:
32156 return NULL;
32157 }
32158
32159
32160 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32161 PyObject *resultobj = 0;
32162 wxWindow *arg1 = (wxWindow *) 0 ;
32163 int *arg2 = (int *) 0 ;
32164 int *arg3 = (int *) 0 ;
32165 void *argp1 = 0 ;
32166 int res1 = 0 ;
32167 int temp2 ;
32168 int res2 = SWIG_TMPOBJ ;
32169 int temp3 ;
32170 int res3 = SWIG_TMPOBJ ;
32171 PyObject *swig_obj[1] ;
32172
32173 arg2 = &temp2;
32174 arg3 = &temp3;
32175 if (!args) SWIG_fail;
32176 swig_obj[0] = args;
32177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32178 if (!SWIG_IsOK(res1)) {
32179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32180 }
32181 arg1 = reinterpret_cast< wxWindow * >(argp1);
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 resultobj = SWIG_Py_Void();
32189 if (SWIG_IsTmpObj(res2)) {
32190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32191 } else {
32192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32194 }
32195 if (SWIG_IsTmpObj(res3)) {
32196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32197 } else {
32198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32200 }
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 wxRect result;
32211 void *argp1 = 0 ;
32212 int res1 = 0 ;
32213 PyObject *swig_obj[1] ;
32214
32215 if (!args) SWIG_fail;
32216 swig_obj[0] = args;
32217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32218 if (!SWIG_IsOK(res1)) {
32219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32220 }
32221 arg1 = reinterpret_cast< wxWindow * >(argp1);
32222 {
32223 PyThreadState* __tstate = wxPyBeginAllowThreads();
32224 result = ((wxWindow const *)arg1)->GetRect();
32225 wxPyEndAllowThreads(__tstate);
32226 if (PyErr_Occurred()) SWIG_fail;
32227 }
32228 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32229 return resultobj;
32230 fail:
32231 return NULL;
32232 }
32233
32234
32235 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32236 PyObject *resultobj = 0;
32237 wxWindow *arg1 = (wxWindow *) 0 ;
32238 wxSize result;
32239 void *argp1 = 0 ;
32240 int res1 = 0 ;
32241 PyObject *swig_obj[1] ;
32242
32243 if (!args) SWIG_fail;
32244 swig_obj[0] = args;
32245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32246 if (!SWIG_IsOK(res1)) {
32247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32248 }
32249 arg1 = reinterpret_cast< wxWindow * >(argp1);
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 result = ((wxWindow const *)arg1)->GetClientSize();
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 int *arg2 = (int *) 0 ;
32267 int *arg3 = (int *) 0 ;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 int temp2 ;
32271 int res2 = SWIG_TMPOBJ ;
32272 int temp3 ;
32273 int res3 = SWIG_TMPOBJ ;
32274 PyObject *swig_obj[1] ;
32275
32276 arg2 = &temp2;
32277 arg3 = &temp3;
32278 if (!args) SWIG_fail;
32279 swig_obj[0] = args;
32280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32281 if (!SWIG_IsOK(res1)) {
32282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32283 }
32284 arg1 = reinterpret_cast< wxWindow * >(argp1);
32285 {
32286 PyThreadState* __tstate = wxPyBeginAllowThreads();
32287 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 resultobj = SWIG_Py_Void();
32292 if (SWIG_IsTmpObj(res2)) {
32293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32294 } else {
32295 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32297 }
32298 if (SWIG_IsTmpObj(res3)) {
32299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32300 } else {
32301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32303 }
32304 return resultobj;
32305 fail:
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311 PyObject *resultobj = 0;
32312 wxWindow *arg1 = (wxWindow *) 0 ;
32313 wxPoint result;
32314 void *argp1 = 0 ;
32315 int res1 = 0 ;
32316 PyObject *swig_obj[1] ;
32317
32318 if (!args) SWIG_fail;
32319 swig_obj[0] = args;
32320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
32323 }
32324 arg1 = reinterpret_cast< wxWindow * >(argp1);
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32339 PyObject *resultobj = 0;
32340 wxWindow *arg1 = (wxWindow *) 0 ;
32341 wxRect result;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 PyObject *swig_obj[1] ;
32345
32346 if (!args) SWIG_fail;
32347 swig_obj[0] = args;
32348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
32351 }
32352 arg1 = reinterpret_cast< wxWindow * >(argp1);
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = ((wxWindow const *)arg1)->GetClientRect();
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 PyObject *resultobj = 0;
32368 wxWindow *arg1 = (wxWindow *) 0 ;
32369 wxSize result;
32370 void *argp1 = 0 ;
32371 int res1 = 0 ;
32372 PyObject *swig_obj[1] ;
32373
32374 if (!args) SWIG_fail;
32375 swig_obj[0] = args;
32376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32377 if (!SWIG_IsOK(res1)) {
32378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32379 }
32380 arg1 = reinterpret_cast< wxWindow * >(argp1);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = ((wxWindow const *)arg1)->GetBestSize();
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 int *arg2 = (int *) 0 ;
32398 int *arg3 = (int *) 0 ;
32399 void *argp1 = 0 ;
32400 int res1 = 0 ;
32401 int temp2 ;
32402 int res2 = SWIG_TMPOBJ ;
32403 int temp3 ;
32404 int res3 = SWIG_TMPOBJ ;
32405 PyObject *swig_obj[1] ;
32406
32407 arg2 = &temp2;
32408 arg3 = &temp3;
32409 if (!args) SWIG_fail;
32410 swig_obj[0] = args;
32411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32412 if (!SWIG_IsOK(res1)) {
32413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32414 }
32415 arg1 = reinterpret_cast< wxWindow * >(argp1);
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_Py_Void();
32423 if (SWIG_IsTmpObj(res2)) {
32424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32425 } else {
32426 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32427 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32428 }
32429 if (SWIG_IsTmpObj(res3)) {
32430 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32431 } else {
32432 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32433 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32434 }
32435 return resultobj;
32436 fail:
32437 return NULL;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 PyObject *resultobj = 0;
32443 wxWindow *arg1 = (wxWindow *) 0 ;
32444 void *argp1 = 0 ;
32445 int res1 = 0 ;
32446 PyObject *swig_obj[1] ;
32447
32448 if (!args) SWIG_fail;
32449 swig_obj[0] = args;
32450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32451 if (!SWIG_IsOK(res1)) {
32452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32453 }
32454 arg1 = reinterpret_cast< wxWindow * >(argp1);
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 (arg1)->InvalidateBestSize();
32458 wxPyEndAllowThreads(__tstate);
32459 if (PyErr_Occurred()) SWIG_fail;
32460 }
32461 resultobj = SWIG_Py_Void();
32462 return resultobj;
32463 fail:
32464 return NULL;
32465 }
32466
32467
32468 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32469 PyObject *resultobj = 0;
32470 wxWindow *arg1 = (wxWindow *) 0 ;
32471 wxSize *arg2 = 0 ;
32472 void *argp1 = 0 ;
32473 int res1 = 0 ;
32474 wxSize temp2 ;
32475 PyObject * obj0 = 0 ;
32476 PyObject * obj1 = 0 ;
32477 char * kwnames[] = {
32478 (char *) "self",(char *) "size", NULL
32479 };
32480
32481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32483 if (!SWIG_IsOK(res1)) {
32484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32485 }
32486 arg1 = reinterpret_cast< wxWindow * >(argp1);
32487 {
32488 arg2 = &temp2;
32489 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32490 }
32491 {
32492 PyThreadState* __tstate = wxPyBeginAllowThreads();
32493 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32494 wxPyEndAllowThreads(__tstate);
32495 if (PyErr_Occurred()) SWIG_fail;
32496 }
32497 resultobj = SWIG_Py_Void();
32498 return resultobj;
32499 fail:
32500 return NULL;
32501 }
32502
32503
32504 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32505 PyObject *resultobj = 0;
32506 wxWindow *arg1 = (wxWindow *) 0 ;
32507 wxSize result;
32508 void *argp1 = 0 ;
32509 int res1 = 0 ;
32510 PyObject *swig_obj[1] ;
32511
32512 if (!args) SWIG_fail;
32513 swig_obj[0] = args;
32514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32515 if (!SWIG_IsOK(res1)) {
32516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32517 }
32518 arg1 = reinterpret_cast< wxWindow * >(argp1);
32519 {
32520 PyThreadState* __tstate = wxPyBeginAllowThreads();
32521 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32522 wxPyEndAllowThreads(__tstate);
32523 if (PyErr_Occurred()) SWIG_fail;
32524 }
32525 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32526 return resultobj;
32527 fail:
32528 return NULL;
32529 }
32530
32531
32532 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32533 PyObject *resultobj = 0;
32534 wxWindow *arg1 = (wxWindow *) 0 ;
32535 wxSize result;
32536 void *argp1 = 0 ;
32537 int res1 = 0 ;
32538 PyObject *swig_obj[1] ;
32539
32540 if (!args) SWIG_fail;
32541 swig_obj[0] = args;
32542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32543 if (!SWIG_IsOK(res1)) {
32544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32545 }
32546 arg1 = reinterpret_cast< wxWindow * >(argp1);
32547 {
32548 PyThreadState* __tstate = wxPyBeginAllowThreads();
32549 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32550 wxPyEndAllowThreads(__tstate);
32551 if (PyErr_Occurred()) SWIG_fail;
32552 }
32553 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32554 return resultobj;
32555 fail:
32556 return NULL;
32557 }
32558
32559
32560 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32561 PyObject *resultobj = 0;
32562 wxWindow *arg1 = (wxWindow *) 0 ;
32563 int arg2 = (int) wxBOTH ;
32564 void *argp1 = 0 ;
32565 int res1 = 0 ;
32566 int val2 ;
32567 int ecode2 = 0 ;
32568 PyObject * obj0 = 0 ;
32569 PyObject * obj1 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "self",(char *) "direction", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32578 }
32579 arg1 = reinterpret_cast< wxWindow * >(argp1);
32580 if (obj1) {
32581 ecode2 = SWIG_AsVal_int(obj1, &val2);
32582 if (!SWIG_IsOK(ecode2)) {
32583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32584 }
32585 arg2 = static_cast< int >(val2);
32586 }
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 (arg1)->Center(arg2);
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 resultobj = SWIG_Py_Void();
32594 return resultobj;
32595 fail:
32596 return NULL;
32597 }
32598
32599
32600 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32601 PyObject *resultobj = 0;
32602 wxWindow *arg1 = (wxWindow *) 0 ;
32603 int arg2 = (int) wxBOTH ;
32604 void *argp1 = 0 ;
32605 int res1 = 0 ;
32606 int val2 ;
32607 int ecode2 = 0 ;
32608 PyObject * obj0 = 0 ;
32609 PyObject * obj1 = 0 ;
32610 char * kwnames[] = {
32611 (char *) "self",(char *) "dir", NULL
32612 };
32613
32614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32618 }
32619 arg1 = reinterpret_cast< wxWindow * >(argp1);
32620 if (obj1) {
32621 ecode2 = SWIG_AsVal_int(obj1, &val2);
32622 if (!SWIG_IsOK(ecode2)) {
32623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32624 }
32625 arg2 = static_cast< int >(val2);
32626 }
32627 {
32628 PyThreadState* __tstate = wxPyBeginAllowThreads();
32629 (arg1)->CenterOnParent(arg2);
32630 wxPyEndAllowThreads(__tstate);
32631 if (PyErr_Occurred()) SWIG_fail;
32632 }
32633 resultobj = SWIG_Py_Void();
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32641 PyObject *resultobj = 0;
32642 wxWindow *arg1 = (wxWindow *) 0 ;
32643 void *argp1 = 0 ;
32644 int res1 = 0 ;
32645 PyObject *swig_obj[1] ;
32646
32647 if (!args) SWIG_fail;
32648 swig_obj[0] = args;
32649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32650 if (!SWIG_IsOK(res1)) {
32651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32652 }
32653 arg1 = reinterpret_cast< wxWindow * >(argp1);
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 (arg1)->Fit();
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 resultobj = SWIG_Py_Void();
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32668 PyObject *resultobj = 0;
32669 wxWindow *arg1 = (wxWindow *) 0 ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32679 }
32680 arg1 = reinterpret_cast< wxWindow * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 (arg1)->FitInside();
32684 wxPyEndAllowThreads(__tstate);
32685 if (PyErr_Occurred()) SWIG_fail;
32686 }
32687 resultobj = SWIG_Py_Void();
32688 return resultobj;
32689 fail:
32690 return NULL;
32691 }
32692
32693
32694 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32695 PyObject *resultobj = 0;
32696 wxWindow *arg1 = (wxWindow *) 0 ;
32697 int arg2 ;
32698 int arg3 ;
32699 int arg4 = (int) -1 ;
32700 int arg5 = (int) -1 ;
32701 int arg6 = (int) -1 ;
32702 int arg7 = (int) -1 ;
32703 void *argp1 = 0 ;
32704 int res1 = 0 ;
32705 int val2 ;
32706 int ecode2 = 0 ;
32707 int val3 ;
32708 int ecode3 = 0 ;
32709 int val4 ;
32710 int ecode4 = 0 ;
32711 int val5 ;
32712 int ecode5 = 0 ;
32713 int val6 ;
32714 int ecode6 = 0 ;
32715 int val7 ;
32716 int ecode7 = 0 ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 PyObject * obj2 = 0 ;
32720 PyObject * obj3 = 0 ;
32721 PyObject * obj4 = 0 ;
32722 PyObject * obj5 = 0 ;
32723 PyObject * obj6 = 0 ;
32724 char * kwnames[] = {
32725 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32726 };
32727
32728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32730 if (!SWIG_IsOK(res1)) {
32731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32732 }
32733 arg1 = reinterpret_cast< wxWindow * >(argp1);
32734 ecode2 = SWIG_AsVal_int(obj1, &val2);
32735 if (!SWIG_IsOK(ecode2)) {
32736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32737 }
32738 arg2 = static_cast< int >(val2);
32739 ecode3 = SWIG_AsVal_int(obj2, &val3);
32740 if (!SWIG_IsOK(ecode3)) {
32741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32742 }
32743 arg3 = static_cast< int >(val3);
32744 if (obj3) {
32745 ecode4 = SWIG_AsVal_int(obj3, &val4);
32746 if (!SWIG_IsOK(ecode4)) {
32747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32748 }
32749 arg4 = static_cast< int >(val4);
32750 }
32751 if (obj4) {
32752 ecode5 = SWIG_AsVal_int(obj4, &val5);
32753 if (!SWIG_IsOK(ecode5)) {
32754 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32755 }
32756 arg5 = static_cast< int >(val5);
32757 }
32758 if (obj5) {
32759 ecode6 = SWIG_AsVal_int(obj5, &val6);
32760 if (!SWIG_IsOK(ecode6)) {
32761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32762 }
32763 arg6 = static_cast< int >(val6);
32764 }
32765 if (obj6) {
32766 ecode7 = SWIG_AsVal_int(obj6, &val7);
32767 if (!SWIG_IsOK(ecode7)) {
32768 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32769 }
32770 arg7 = static_cast< int >(val7);
32771 }
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32775 wxPyEndAllowThreads(__tstate);
32776 if (PyErr_Occurred()) SWIG_fail;
32777 }
32778 resultobj = SWIG_Py_Void();
32779 return resultobj;
32780 fail:
32781 return NULL;
32782 }
32783
32784
32785 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32786 PyObject *resultobj = 0;
32787 wxWindow *arg1 = (wxWindow *) 0 ;
32788 wxSize *arg2 = 0 ;
32789 wxSize const &arg3_defvalue = wxDefaultSize ;
32790 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32791 wxSize const &arg4_defvalue = wxDefaultSize ;
32792 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 wxSize temp2 ;
32796 wxSize temp3 ;
32797 wxSize temp4 ;
32798 PyObject * obj0 = 0 ;
32799 PyObject * obj1 = 0 ;
32800 PyObject * obj2 = 0 ;
32801 PyObject * obj3 = 0 ;
32802 char * kwnames[] = {
32803 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32804 };
32805
32806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32808 if (!SWIG_IsOK(res1)) {
32809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32810 }
32811 arg1 = reinterpret_cast< wxWindow * >(argp1);
32812 {
32813 arg2 = &temp2;
32814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32815 }
32816 if (obj2) {
32817 {
32818 arg3 = &temp3;
32819 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32820 }
32821 }
32822 if (obj3) {
32823 {
32824 arg4 = &temp4;
32825 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32826 }
32827 }
32828 {
32829 PyThreadState* __tstate = wxPyBeginAllowThreads();
32830 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32831 wxPyEndAllowThreads(__tstate);
32832 if (PyErr_Occurred()) SWIG_fail;
32833 }
32834 resultobj = SWIG_Py_Void();
32835 return resultobj;
32836 fail:
32837 return NULL;
32838 }
32839
32840
32841 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32842 PyObject *resultobj = 0;
32843 wxWindow *arg1 = (wxWindow *) 0 ;
32844 int arg2 ;
32845 int arg3 ;
32846 int arg4 = (int) -1 ;
32847 int arg5 = (int) -1 ;
32848 void *argp1 = 0 ;
32849 int res1 = 0 ;
32850 int val2 ;
32851 int ecode2 = 0 ;
32852 int val3 ;
32853 int ecode3 = 0 ;
32854 int val4 ;
32855 int ecode4 = 0 ;
32856 int val5 ;
32857 int ecode5 = 0 ;
32858 PyObject * obj0 = 0 ;
32859 PyObject * obj1 = 0 ;
32860 PyObject * obj2 = 0 ;
32861 PyObject * obj3 = 0 ;
32862 PyObject * obj4 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32871 }
32872 arg1 = reinterpret_cast< wxWindow * >(argp1);
32873 ecode2 = SWIG_AsVal_int(obj1, &val2);
32874 if (!SWIG_IsOK(ecode2)) {
32875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32876 }
32877 arg2 = static_cast< int >(val2);
32878 ecode3 = SWIG_AsVal_int(obj2, &val3);
32879 if (!SWIG_IsOK(ecode3)) {
32880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32881 }
32882 arg3 = static_cast< int >(val3);
32883 if (obj3) {
32884 ecode4 = SWIG_AsVal_int(obj3, &val4);
32885 if (!SWIG_IsOK(ecode4)) {
32886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32887 }
32888 arg4 = static_cast< int >(val4);
32889 }
32890 if (obj4) {
32891 ecode5 = SWIG_AsVal_int(obj4, &val5);
32892 if (!SWIG_IsOK(ecode5)) {
32893 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32894 }
32895 arg5 = static_cast< int >(val5);
32896 }
32897 {
32898 PyThreadState* __tstate = wxPyBeginAllowThreads();
32899 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32900 wxPyEndAllowThreads(__tstate);
32901 if (PyErr_Occurred()) SWIG_fail;
32902 }
32903 resultobj = SWIG_Py_Void();
32904 return resultobj;
32905 fail:
32906 return NULL;
32907 }
32908
32909
32910 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32911 PyObject *resultobj = 0;
32912 wxWindow *arg1 = (wxWindow *) 0 ;
32913 wxSize *arg2 = 0 ;
32914 wxSize const &arg3_defvalue = wxDefaultSize ;
32915 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32916 void *argp1 = 0 ;
32917 int res1 = 0 ;
32918 wxSize temp2 ;
32919 wxSize temp3 ;
32920 PyObject * obj0 = 0 ;
32921 PyObject * obj1 = 0 ;
32922 PyObject * obj2 = 0 ;
32923 char * kwnames[] = {
32924 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32925 };
32926
32927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32929 if (!SWIG_IsOK(res1)) {
32930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32931 }
32932 arg1 = reinterpret_cast< wxWindow * >(argp1);
32933 {
32934 arg2 = &temp2;
32935 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32936 }
32937 if (obj2) {
32938 {
32939 arg3 = &temp3;
32940 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32941 }
32942 }
32943 {
32944 PyThreadState* __tstate = wxPyBeginAllowThreads();
32945 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32946 wxPyEndAllowThreads(__tstate);
32947 if (PyErr_Occurred()) SWIG_fail;
32948 }
32949 resultobj = SWIG_Py_Void();
32950 return resultobj;
32951 fail:
32952 return NULL;
32953 }
32954
32955
32956 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32957 PyObject *resultobj = 0;
32958 wxWindow *arg1 = (wxWindow *) 0 ;
32959 wxSize result;
32960 void *argp1 = 0 ;
32961 int res1 = 0 ;
32962 PyObject *swig_obj[1] ;
32963
32964 if (!args) SWIG_fail;
32965 swig_obj[0] = args;
32966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res1)) {
32968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32969 }
32970 arg1 = reinterpret_cast< wxWindow * >(argp1);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = ((wxWindow const *)arg1)->GetMaxSize();
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32978 return resultobj;
32979 fail:
32980 return NULL;
32981 }
32982
32983
32984 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32985 PyObject *resultobj = 0;
32986 wxWindow *arg1 = (wxWindow *) 0 ;
32987 wxSize result;
32988 void *argp1 = 0 ;
32989 int res1 = 0 ;
32990 PyObject *swig_obj[1] ;
32991
32992 if (!args) SWIG_fail;
32993 swig_obj[0] = args;
32994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32995 if (!SWIG_IsOK(res1)) {
32996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32997 }
32998 arg1 = reinterpret_cast< wxWindow * >(argp1);
32999 {
33000 PyThreadState* __tstate = wxPyBeginAllowThreads();
33001 result = ((wxWindow const *)arg1)->GetMinSize();
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj = 0;
33014 wxWindow *arg1 = (wxWindow *) 0 ;
33015 wxSize *arg2 = 0 ;
33016 void *argp1 = 0 ;
33017 int res1 = 0 ;
33018 wxSize temp2 ;
33019 PyObject * obj0 = 0 ;
33020 PyObject * obj1 = 0 ;
33021 char * kwnames[] = {
33022 (char *) "self",(char *) "minSize", NULL
33023 };
33024
33025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
33026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33027 if (!SWIG_IsOK(res1)) {
33028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33029 }
33030 arg1 = reinterpret_cast< wxWindow * >(argp1);
33031 {
33032 arg2 = &temp2;
33033 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33034 }
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->SetMinSize((wxSize const &)*arg2);
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 resultobj = SWIG_Py_Void();
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 wxSize *arg2 = 0 ;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 wxSize temp2 ;
33055 PyObject * obj0 = 0 ;
33056 PyObject * obj1 = 0 ;
33057 char * kwnames[] = {
33058 (char *) "self",(char *) "maxSize", NULL
33059 };
33060
33061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
33062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33063 if (!SWIG_IsOK(res1)) {
33064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33065 }
33066 arg1 = reinterpret_cast< wxWindow * >(argp1);
33067 {
33068 arg2 = &temp2;
33069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33070 }
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 (arg1)->SetMaxSize((wxSize const &)*arg2);
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 resultobj = SWIG_Py_Void();
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33085 PyObject *resultobj = 0;
33086 wxWindow *arg1 = (wxWindow *) 0 ;
33087 int result;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 PyObject *swig_obj[1] ;
33091
33092 if (!args) SWIG_fail;
33093 swig_obj[0] = args;
33094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33095 if (!SWIG_IsOK(res1)) {
33096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33097 }
33098 arg1 = reinterpret_cast< wxWindow * >(argp1);
33099 {
33100 PyThreadState* __tstate = wxPyBeginAllowThreads();
33101 result = (int)((wxWindow const *)arg1)->GetMinWidth();
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 resultobj = SWIG_From_int(static_cast< int >(result));
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33113 PyObject *resultobj = 0;
33114 wxWindow *arg1 = (wxWindow *) 0 ;
33115 int result;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject *swig_obj[1] ;
33119
33120 if (!args) SWIG_fail;
33121 swig_obj[0] = args;
33122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (int)((wxWindow const *)arg1)->GetMinHeight();
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 resultobj = SWIG_From_int(static_cast< int >(result));
33134 return resultobj;
33135 fail:
33136 return NULL;
33137 }
33138
33139
33140 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33141 PyObject *resultobj = 0;
33142 wxWindow *arg1 = (wxWindow *) 0 ;
33143 int result;
33144 void *argp1 = 0 ;
33145 int res1 = 0 ;
33146 PyObject *swig_obj[1] ;
33147
33148 if (!args) SWIG_fail;
33149 swig_obj[0] = args;
33150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33151 if (!SWIG_IsOK(res1)) {
33152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
33153 }
33154 arg1 = reinterpret_cast< wxWindow * >(argp1);
33155 {
33156 PyThreadState* __tstate = wxPyBeginAllowThreads();
33157 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
33158 wxPyEndAllowThreads(__tstate);
33159 if (PyErr_Occurred()) SWIG_fail;
33160 }
33161 resultobj = SWIG_From_int(static_cast< int >(result));
33162 return resultobj;
33163 fail:
33164 return NULL;
33165 }
33166
33167
33168 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33169 PyObject *resultobj = 0;
33170 wxWindow *arg1 = (wxWindow *) 0 ;
33171 int result;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 PyObject *swig_obj[1] ;
33175
33176 if (!args) SWIG_fail;
33177 swig_obj[0] = args;
33178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33179 if (!SWIG_IsOK(res1)) {
33180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
33181 }
33182 arg1 = reinterpret_cast< wxWindow * >(argp1);
33183 {
33184 PyThreadState* __tstate = wxPyBeginAllowThreads();
33185 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 resultobj = SWIG_From_int(static_cast< int >(result));
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 wxSize *arg2 = 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 wxSize temp2 ;
33203 PyObject * obj0 = 0 ;
33204 PyObject * obj1 = 0 ;
33205 char * kwnames[] = {
33206 (char *) "self",(char *) "size", NULL
33207 };
33208
33209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
33210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33213 }
33214 arg1 = reinterpret_cast< wxWindow * >(argp1);
33215 {
33216 arg2 = &temp2;
33217 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33218 }
33219 {
33220 PyThreadState* __tstate = wxPyBeginAllowThreads();
33221 (arg1)->SetVirtualSize((wxSize const &)*arg2);
33222 wxPyEndAllowThreads(__tstate);
33223 if (PyErr_Occurred()) SWIG_fail;
33224 }
33225 resultobj = SWIG_Py_Void();
33226 return resultobj;
33227 fail:
33228 return NULL;
33229 }
33230
33231
33232 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33233 PyObject *resultobj = 0;
33234 wxWindow *arg1 = (wxWindow *) 0 ;
33235 int arg2 ;
33236 int arg3 ;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 int val2 ;
33240 int ecode2 = 0 ;
33241 int val3 ;
33242 int ecode3 = 0 ;
33243 PyObject * obj0 = 0 ;
33244 PyObject * obj1 = 0 ;
33245 PyObject * obj2 = 0 ;
33246 char * kwnames[] = {
33247 (char *) "self",(char *) "w",(char *) "h", NULL
33248 };
33249
33250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33254 }
33255 arg1 = reinterpret_cast< wxWindow * >(argp1);
33256 ecode2 = SWIG_AsVal_int(obj1, &val2);
33257 if (!SWIG_IsOK(ecode2)) {
33258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
33259 }
33260 arg2 = static_cast< int >(val2);
33261 ecode3 = SWIG_AsVal_int(obj2, &val3);
33262 if (!SWIG_IsOK(ecode3)) {
33263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
33264 }
33265 arg3 = static_cast< int >(val3);
33266 {
33267 PyThreadState* __tstate = wxPyBeginAllowThreads();
33268 (arg1)->SetVirtualSize(arg2,arg3);
33269 wxPyEndAllowThreads(__tstate);
33270 if (PyErr_Occurred()) SWIG_fail;
33271 }
33272 resultobj = SWIG_Py_Void();
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 wxSize result;
33283 void *argp1 = 0 ;
33284 int res1 = 0 ;
33285 PyObject *swig_obj[1] ;
33286
33287 if (!args) SWIG_fail;
33288 swig_obj[0] = args;
33289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 PyThreadState* __tstate = wxPyBeginAllowThreads();
33296 result = ((wxWindow const *)arg1)->GetVirtualSize();
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33301 return resultobj;
33302 fail:
33303 return NULL;
33304 }
33305
33306
33307 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33308 PyObject *resultobj = 0;
33309 wxWindow *arg1 = (wxWindow *) 0 ;
33310 int *arg2 = (int *) 0 ;
33311 int *arg3 = (int *) 0 ;
33312 void *argp1 = 0 ;
33313 int res1 = 0 ;
33314 int temp2 ;
33315 int res2 = SWIG_TMPOBJ ;
33316 int temp3 ;
33317 int res3 = SWIG_TMPOBJ ;
33318 PyObject *swig_obj[1] ;
33319
33320 arg2 = &temp2;
33321 arg3 = &temp3;
33322 if (!args) SWIG_fail;
33323 swig_obj[0] = args;
33324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33325 if (!SWIG_IsOK(res1)) {
33326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
33327 }
33328 arg1 = reinterpret_cast< wxWindow * >(argp1);
33329 {
33330 PyThreadState* __tstate = wxPyBeginAllowThreads();
33331 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
33332 wxPyEndAllowThreads(__tstate);
33333 if (PyErr_Occurred()) SWIG_fail;
33334 }
33335 resultobj = SWIG_Py_Void();
33336 if (SWIG_IsTmpObj(res2)) {
33337 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
33338 } else {
33339 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33340 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
33341 }
33342 if (SWIG_IsTmpObj(res3)) {
33343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
33344 } else {
33345 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
33346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33355 PyObject *resultobj = 0;
33356 wxWindow *arg1 = (wxWindow *) 0 ;
33357 wxSize result;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 PyObject *swig_obj[1] ;
33361
33362 if (!args) SWIG_fail;
33363 swig_obj[0] = args;
33364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33365 if (!SWIG_IsOK(res1)) {
33366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
33367 }
33368 arg1 = reinterpret_cast< wxWindow * >(argp1);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 bool arg2 = (bool) true ;
33386 bool result;
33387 void *argp1 = 0 ;
33388 int res1 = 0 ;
33389 bool val2 ;
33390 int ecode2 = 0 ;
33391 PyObject * obj0 = 0 ;
33392 PyObject * obj1 = 0 ;
33393 char * kwnames[] = {
33394 (char *) "self",(char *) "show", NULL
33395 };
33396
33397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
33398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33399 if (!SWIG_IsOK(res1)) {
33400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
33401 }
33402 arg1 = reinterpret_cast< wxWindow * >(argp1);
33403 if (obj1) {
33404 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33405 if (!SWIG_IsOK(ecode2)) {
33406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
33407 }
33408 arg2 = static_cast< bool >(val2);
33409 }
33410 {
33411 PyThreadState* __tstate = wxPyBeginAllowThreads();
33412 result = (bool)(arg1)->Show(arg2);
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33418 }
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 bool result;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 PyObject *swig_obj[1] ;
33432
33433 if (!args) SWIG_fail;
33434 swig_obj[0] = args;
33435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 {
33441 PyThreadState* __tstate = wxPyBeginAllowThreads();
33442 result = (bool)(arg1)->Hide();
33443 wxPyEndAllowThreads(__tstate);
33444 if (PyErr_Occurred()) SWIG_fail;
33445 }
33446 {
33447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33448 }
33449 return resultobj;
33450 fail:
33451 return NULL;
33452 }
33453
33454
33455 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33456 PyObject *resultobj = 0;
33457 wxWindow *arg1 = (wxWindow *) 0 ;
33458 bool arg2 = (bool) true ;
33459 bool result;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 bool val2 ;
33463 int ecode2 = 0 ;
33464 PyObject * obj0 = 0 ;
33465 PyObject * obj1 = 0 ;
33466 char * kwnames[] = {
33467 (char *) "self",(char *) "enable", NULL
33468 };
33469
33470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33472 if (!SWIG_IsOK(res1)) {
33473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33474 }
33475 arg1 = reinterpret_cast< wxWindow * >(argp1);
33476 if (obj1) {
33477 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33478 if (!SWIG_IsOK(ecode2)) {
33479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33480 }
33481 arg2 = static_cast< bool >(val2);
33482 }
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 result = (bool)(arg1)->Enable(arg2);
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 {
33490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33491 }
33492 return resultobj;
33493 fail:
33494 return NULL;
33495 }
33496
33497
33498 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33499 PyObject *resultobj = 0;
33500 wxWindow *arg1 = (wxWindow *) 0 ;
33501 bool result;
33502 void *argp1 = 0 ;
33503 int res1 = 0 ;
33504 PyObject *swig_obj[1] ;
33505
33506 if (!args) SWIG_fail;
33507 swig_obj[0] = args;
33508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33509 if (!SWIG_IsOK(res1)) {
33510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33511 }
33512 arg1 = reinterpret_cast< wxWindow * >(argp1);
33513 {
33514 PyThreadState* __tstate = wxPyBeginAllowThreads();
33515 result = (bool)(arg1)->Disable();
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 PyObject *resultobj = 0;
33530 wxWindow *arg1 = (wxWindow *) 0 ;
33531 bool result;
33532 void *argp1 = 0 ;
33533 int res1 = 0 ;
33534 PyObject *swig_obj[1] ;
33535
33536 if (!args) SWIG_fail;
33537 swig_obj[0] = args;
33538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33539 if (!SWIG_IsOK(res1)) {
33540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33541 }
33542 arg1 = reinterpret_cast< wxWindow * >(argp1);
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (bool)((wxWindow const *)arg1)->IsShown();
33546 wxPyEndAllowThreads(__tstate);
33547 if (PyErr_Occurred()) SWIG_fail;
33548 }
33549 {
33550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33551 }
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 bool result;
33562 void *argp1 = 0 ;
33563 int res1 = 0 ;
33564 PyObject *swig_obj[1] ;
33565
33566 if (!args) SWIG_fail;
33567 swig_obj[0] = args;
33568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33569 if (!SWIG_IsOK(res1)) {
33570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33571 }
33572 arg1 = reinterpret_cast< wxWindow * >(argp1);
33573 {
33574 PyThreadState* __tstate = wxPyBeginAllowThreads();
33575 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33576 wxPyEndAllowThreads(__tstate);
33577 if (PyErr_Occurred()) SWIG_fail;
33578 }
33579 {
33580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33581 }
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33589 PyObject *resultobj = 0;
33590 wxWindow *arg1 = (wxWindow *) 0 ;
33591 bool result;
33592 void *argp1 = 0 ;
33593 int res1 = 0 ;
33594 PyObject *swig_obj[1] ;
33595
33596 if (!args) SWIG_fail;
33597 swig_obj[0] = args;
33598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33599 if (!SWIG_IsOK(res1)) {
33600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33601 }
33602 arg1 = reinterpret_cast< wxWindow * >(argp1);
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33606 wxPyEndAllowThreads(__tstate);
33607 if (PyErr_Occurred()) SWIG_fail;
33608 }
33609 {
33610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33611 }
33612 return resultobj;
33613 fail:
33614 return NULL;
33615 }
33616
33617
33618 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33619 PyObject *resultobj = 0;
33620 wxWindow *arg1 = (wxWindow *) 0 ;
33621 long arg2 ;
33622 void *argp1 = 0 ;
33623 int res1 = 0 ;
33624 long val2 ;
33625 int ecode2 = 0 ;
33626 PyObject * obj0 = 0 ;
33627 PyObject * obj1 = 0 ;
33628 char * kwnames[] = {
33629 (char *) "self",(char *) "style", NULL
33630 };
33631
33632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33634 if (!SWIG_IsOK(res1)) {
33635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33636 }
33637 arg1 = reinterpret_cast< wxWindow * >(argp1);
33638 ecode2 = SWIG_AsVal_long(obj1, &val2);
33639 if (!SWIG_IsOK(ecode2)) {
33640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33641 }
33642 arg2 = static_cast< long >(val2);
33643 {
33644 PyThreadState* __tstate = wxPyBeginAllowThreads();
33645 (arg1)->SetWindowStyleFlag(arg2);
33646 wxPyEndAllowThreads(__tstate);
33647 if (PyErr_Occurred()) SWIG_fail;
33648 }
33649 resultobj = SWIG_Py_Void();
33650 return resultobj;
33651 fail:
33652 return NULL;
33653 }
33654
33655
33656 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33657 PyObject *resultobj = 0;
33658 wxWindow *arg1 = (wxWindow *) 0 ;
33659 long result;
33660 void *argp1 = 0 ;
33661 int res1 = 0 ;
33662 PyObject *swig_obj[1] ;
33663
33664 if (!args) SWIG_fail;
33665 swig_obj[0] = args;
33666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33667 if (!SWIG_IsOK(res1)) {
33668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33669 }
33670 arg1 = reinterpret_cast< wxWindow * >(argp1);
33671 {
33672 PyThreadState* __tstate = wxPyBeginAllowThreads();
33673 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33674 wxPyEndAllowThreads(__tstate);
33675 if (PyErr_Occurred()) SWIG_fail;
33676 }
33677 resultobj = SWIG_From_long(static_cast< long >(result));
33678 return resultobj;
33679 fail:
33680 return NULL;
33681 }
33682
33683
33684 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj = 0;
33686 wxWindow *arg1 = (wxWindow *) 0 ;
33687 int arg2 ;
33688 bool result;
33689 void *argp1 = 0 ;
33690 int res1 = 0 ;
33691 int val2 ;
33692 int ecode2 = 0 ;
33693 PyObject * obj0 = 0 ;
33694 PyObject * obj1 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "flag", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 ecode2 = SWIG_AsVal_int(obj1, &val2);
33706 if (!SWIG_IsOK(ecode2)) {
33707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33708 }
33709 arg2 = static_cast< int >(val2);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 {
33717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33718 }
33719 return resultobj;
33720 fail:
33721 return NULL;
33722 }
33723
33724
33725 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33726 PyObject *resultobj = 0;
33727 wxWindow *arg1 = (wxWindow *) 0 ;
33728 bool result;
33729 void *argp1 = 0 ;
33730 int res1 = 0 ;
33731 PyObject *swig_obj[1] ;
33732
33733 if (!args) SWIG_fail;
33734 swig_obj[0] = args;
33735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33736 if (!SWIG_IsOK(res1)) {
33737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33738 }
33739 arg1 = reinterpret_cast< wxWindow * >(argp1);
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 result = (bool)((wxWindow const *)arg1)->IsRetained();
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 {
33747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33748 }
33749 return resultobj;
33750 fail:
33751 return NULL;
33752 }
33753
33754
33755 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33756 PyObject *resultobj = 0;
33757 wxWindow *arg1 = (wxWindow *) 0 ;
33758 long arg2 ;
33759 void *argp1 = 0 ;
33760 int res1 = 0 ;
33761 long val2 ;
33762 int ecode2 = 0 ;
33763 PyObject * obj0 = 0 ;
33764 PyObject * obj1 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "exStyle", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 ecode2 = SWIG_AsVal_long(obj1, &val2);
33776 if (!SWIG_IsOK(ecode2)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33778 }
33779 arg2 = static_cast< long >(val2);
33780 {
33781 PyThreadState* __tstate = wxPyBeginAllowThreads();
33782 (arg1)->SetExtraStyle(arg2);
33783 wxPyEndAllowThreads(__tstate);
33784 if (PyErr_Occurred()) SWIG_fail;
33785 }
33786 resultobj = SWIG_Py_Void();
33787 return resultobj;
33788 fail:
33789 return NULL;
33790 }
33791
33792
33793 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33794 PyObject *resultobj = 0;
33795 wxWindow *arg1 = (wxWindow *) 0 ;
33796 long result;
33797 void *argp1 = 0 ;
33798 int res1 = 0 ;
33799 PyObject *swig_obj[1] ;
33800
33801 if (!args) SWIG_fail;
33802 swig_obj[0] = args;
33803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33804 if (!SWIG_IsOK(res1)) {
33805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33806 }
33807 arg1 = reinterpret_cast< wxWindow * >(argp1);
33808 {
33809 PyThreadState* __tstate = wxPyBeginAllowThreads();
33810 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 resultobj = SWIG_From_long(static_cast< long >(result));
33815 return resultobj;
33816 fail:
33817 return NULL;
33818 }
33819
33820
33821 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33822 PyObject *resultobj = 0;
33823 wxWindow *arg1 = (wxWindow *) 0 ;
33824 bool arg2 = (bool) true ;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 bool val2 ;
33828 int ecode2 = 0 ;
33829 PyObject * obj0 = 0 ;
33830 PyObject * obj1 = 0 ;
33831 char * kwnames[] = {
33832 (char *) "self",(char *) "modal", NULL
33833 };
33834
33835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33837 if (!SWIG_IsOK(res1)) {
33838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33839 }
33840 arg1 = reinterpret_cast< wxWindow * >(argp1);
33841 if (obj1) {
33842 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33843 if (!SWIG_IsOK(ecode2)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33845 }
33846 arg2 = static_cast< bool >(val2);
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 (arg1)->MakeModal(arg2);
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_Py_Void();
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 bool arg2 ;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 bool val2 ;
33868 int ecode2 = 0 ;
33869 PyObject * obj0 = 0 ;
33870 PyObject * obj1 = 0 ;
33871 char * kwnames[] = {
33872 (char *) "self",(char *) "enableTheme", NULL
33873 };
33874
33875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33877 if (!SWIG_IsOK(res1)) {
33878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33879 }
33880 arg1 = reinterpret_cast< wxWindow * >(argp1);
33881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33882 if (!SWIG_IsOK(ecode2)) {
33883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33884 }
33885 arg2 = static_cast< bool >(val2);
33886 {
33887 PyThreadState* __tstate = wxPyBeginAllowThreads();
33888 (arg1)->SetThemeEnabled(arg2);
33889 wxPyEndAllowThreads(__tstate);
33890 if (PyErr_Occurred()) SWIG_fail;
33891 }
33892 resultobj = SWIG_Py_Void();
33893 return resultobj;
33894 fail:
33895 return NULL;
33896 }
33897
33898
33899 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33900 PyObject *resultobj = 0;
33901 wxWindow *arg1 = (wxWindow *) 0 ;
33902 bool result;
33903 void *argp1 = 0 ;
33904 int res1 = 0 ;
33905 PyObject *swig_obj[1] ;
33906
33907 if (!args) SWIG_fail;
33908 swig_obj[0] = args;
33909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 {
33921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33922 }
33923 return resultobj;
33924 fail:
33925 return NULL;
33926 }
33927
33928
33929 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33930 PyObject *resultobj = 0;
33931 wxWindow *arg1 = (wxWindow *) 0 ;
33932 void *argp1 = 0 ;
33933 int res1 = 0 ;
33934 PyObject *swig_obj[1] ;
33935
33936 if (!args) SWIG_fail;
33937 swig_obj[0] = args;
33938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33939 if (!SWIG_IsOK(res1)) {
33940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33941 }
33942 arg1 = reinterpret_cast< wxWindow * >(argp1);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 (arg1)->SetFocus();
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 resultobj = SWIG_Py_Void();
33950 return resultobj;
33951 fail:
33952 return NULL;
33953 }
33954
33955
33956 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33957 PyObject *resultobj = 0;
33958 wxWindow *arg1 = (wxWindow *) 0 ;
33959 void *argp1 = 0 ;
33960 int res1 = 0 ;
33961 PyObject *swig_obj[1] ;
33962
33963 if (!args) SWIG_fail;
33964 swig_obj[0] = args;
33965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33966 if (!SWIG_IsOK(res1)) {
33967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33968 }
33969 arg1 = reinterpret_cast< wxWindow * >(argp1);
33970 {
33971 PyThreadState* __tstate = wxPyBeginAllowThreads();
33972 (arg1)->SetFocusFromKbd();
33973 wxPyEndAllowThreads(__tstate);
33974 if (PyErr_Occurred()) SWIG_fail;
33975 }
33976 resultobj = SWIG_Py_Void();
33977 return resultobj;
33978 fail:
33979 return NULL;
33980 }
33981
33982
33983 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33984 PyObject *resultobj = 0;
33985 wxWindow *result = 0 ;
33986
33987 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33988 {
33989 if (!wxPyCheckForApp()) SWIG_fail;
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (wxWindow *)wxWindow::FindFocus();
33992 wxPyEndAllowThreads(__tstate);
33993 if (PyErr_Occurred()) SWIG_fail;
33994 }
33995 {
33996 resultobj = wxPyMake_wxObject(result, 0);
33997 }
33998 return resultobj;
33999 fail:
34000 return NULL;
34001 }
34002
34003
34004 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34005 PyObject *resultobj = 0;
34006 wxWindow *arg1 = (wxWindow *) 0 ;
34007 bool result;
34008 void *argp1 = 0 ;
34009 int res1 = 0 ;
34010 PyObject *swig_obj[1] ;
34011
34012 if (!args) SWIG_fail;
34013 swig_obj[0] = args;
34014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34015 if (!SWIG_IsOK(res1)) {
34016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
34017 }
34018 arg1 = reinterpret_cast< wxWindow * >(argp1);
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 {
34026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34027 }
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34035 PyObject *resultobj = 0;
34036 wxWindow *arg1 = (wxWindow *) 0 ;
34037 bool result;
34038 void *argp1 = 0 ;
34039 int res1 = 0 ;
34040 PyObject *swig_obj[1] ;
34041
34042 if (!args) SWIG_fail;
34043 swig_obj[0] = args;
34044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34045 if (!SWIG_IsOK(res1)) {
34046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
34047 }
34048 arg1 = reinterpret_cast< wxWindow * >(argp1);
34049 {
34050 PyThreadState* __tstate = wxPyBeginAllowThreads();
34051 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
34052 wxPyEndAllowThreads(__tstate);
34053 if (PyErr_Occurred()) SWIG_fail;
34054 }
34055 {
34056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34057 }
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
34068 bool result;
34069 void *argp1 = 0 ;
34070 int res1 = 0 ;
34071 int val2 ;
34072 int ecode2 = 0 ;
34073 PyObject * obj0 = 0 ;
34074 PyObject * obj1 = 0 ;
34075 char * kwnames[] = {
34076 (char *) "self",(char *) "flags", NULL
34077 };
34078
34079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
34080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34081 if (!SWIG_IsOK(res1)) {
34082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
34083 }
34084 arg1 = reinterpret_cast< wxWindow * >(argp1);
34085 if (obj1) {
34086 ecode2 = SWIG_AsVal_int(obj1, &val2);
34087 if (!SWIG_IsOK(ecode2)) {
34088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
34089 }
34090 arg2 = static_cast< int >(val2);
34091 }
34092 {
34093 PyThreadState* __tstate = wxPyBeginAllowThreads();
34094 result = (bool)(arg1)->Navigate(arg2);
34095 wxPyEndAllowThreads(__tstate);
34096 if (PyErr_Occurred()) SWIG_fail;
34097 }
34098 {
34099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34100 }
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 wxWindow *arg2 = (wxWindow *) 0 ;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 void *argp2 = 0 ;
34114 int res2 = 0 ;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char * kwnames[] = {
34118 (char *) "self",(char *) "win", NULL
34119 };
34120
34121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34123 if (!SWIG_IsOK(res1)) {
34124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34125 }
34126 arg1 = reinterpret_cast< wxWindow * >(argp1);
34127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34128 if (!SWIG_IsOK(res2)) {
34129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34130 }
34131 arg2 = reinterpret_cast< wxWindow * >(argp2);
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 (arg1)->MoveAfterInTabOrder(arg2);
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 resultobj = SWIG_Py_Void();
34139 return resultobj;
34140 fail:
34141 return NULL;
34142 }
34143
34144
34145 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34146 PyObject *resultobj = 0;
34147 wxWindow *arg1 = (wxWindow *) 0 ;
34148 wxWindow *arg2 = (wxWindow *) 0 ;
34149 void *argp1 = 0 ;
34150 int res1 = 0 ;
34151 void *argp2 = 0 ;
34152 int res2 = 0 ;
34153 PyObject * obj0 = 0 ;
34154 PyObject * obj1 = 0 ;
34155 char * kwnames[] = {
34156 (char *) "self",(char *) "win", NULL
34157 };
34158
34159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
34160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34161 if (!SWIG_IsOK(res1)) {
34162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
34163 }
34164 arg1 = reinterpret_cast< wxWindow * >(argp1);
34165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34166 if (!SWIG_IsOK(res2)) {
34167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
34168 }
34169 arg2 = reinterpret_cast< wxWindow * >(argp2);
34170 {
34171 PyThreadState* __tstate = wxPyBeginAllowThreads();
34172 (arg1)->MoveBeforeInTabOrder(arg2);
34173 wxPyEndAllowThreads(__tstate);
34174 if (PyErr_Occurred()) SWIG_fail;
34175 }
34176 resultobj = SWIG_Py_Void();
34177 return resultobj;
34178 fail:
34179 return NULL;
34180 }
34181
34182
34183 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34184 PyObject *resultobj = 0;
34185 wxWindow *arg1 = (wxWindow *) 0 ;
34186 PyObject *result = 0 ;
34187 void *argp1 = 0 ;
34188 int res1 = 0 ;
34189 PyObject *swig_obj[1] ;
34190
34191 if (!args) SWIG_fail;
34192 swig_obj[0] = args;
34193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34194 if (!SWIG_IsOK(res1)) {
34195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
34196 }
34197 arg1 = reinterpret_cast< wxWindow * >(argp1);
34198 {
34199 PyThreadState* __tstate = wxPyBeginAllowThreads();
34200 result = (PyObject *)wxWindow_GetChildren(arg1);
34201 wxPyEndAllowThreads(__tstate);
34202 if (PyErr_Occurred()) SWIG_fail;
34203 }
34204 resultobj = result;
34205 return resultobj;
34206 fail:
34207 return NULL;
34208 }
34209
34210
34211 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34212 PyObject *resultobj = 0;
34213 wxWindow *arg1 = (wxWindow *) 0 ;
34214 wxWindow *result = 0 ;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 PyObject *swig_obj[1] ;
34218
34219 if (!args) SWIG_fail;
34220 swig_obj[0] = args;
34221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34222 if (!SWIG_IsOK(res1)) {
34223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34224 }
34225 arg1 = reinterpret_cast< wxWindow * >(argp1);
34226 {
34227 PyThreadState* __tstate = wxPyBeginAllowThreads();
34228 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
34229 wxPyEndAllowThreads(__tstate);
34230 if (PyErr_Occurred()) SWIG_fail;
34231 }
34232 {
34233 resultobj = wxPyMake_wxObject(result, 0);
34234 }
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34242 PyObject *resultobj = 0;
34243 wxWindow *arg1 = (wxWindow *) 0 ;
34244 wxWindow *result = 0 ;
34245 void *argp1 = 0 ;
34246 int res1 = 0 ;
34247 PyObject *swig_obj[1] ;
34248
34249 if (!args) SWIG_fail;
34250 swig_obj[0] = args;
34251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34252 if (!SWIG_IsOK(res1)) {
34253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
34254 }
34255 arg1 = reinterpret_cast< wxWindow * >(argp1);
34256 {
34257 PyThreadState* __tstate = wxPyBeginAllowThreads();
34258 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
34259 wxPyEndAllowThreads(__tstate);
34260 if (PyErr_Occurred()) SWIG_fail;
34261 }
34262 {
34263 resultobj = wxPyMake_wxObject(result, 0);
34264 }
34265 return resultobj;
34266 fail:
34267 return NULL;
34268 }
34269
34270
34271 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34272 PyObject *resultobj = 0;
34273 wxWindow *arg1 = (wxWindow *) 0 ;
34274 bool result;
34275 void *argp1 = 0 ;
34276 int res1 = 0 ;
34277 PyObject *swig_obj[1] ;
34278
34279 if (!args) SWIG_fail;
34280 swig_obj[0] = args;
34281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34282 if (!SWIG_IsOK(res1)) {
34283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
34284 }
34285 arg1 = reinterpret_cast< wxWindow * >(argp1);
34286 {
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 {
34293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34294 }
34295 return resultobj;
34296 fail:
34297 return NULL;
34298 }
34299
34300
34301 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34302 PyObject *resultobj = 0;
34303 wxWindow *arg1 = (wxWindow *) 0 ;
34304 wxWindow *arg2 = (wxWindow *) 0 ;
34305 bool result;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 void *argp2 = 0 ;
34309 int res2 = 0 ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 char * kwnames[] = {
34313 (char *) "self",(char *) "newParent", NULL
34314 };
34315
34316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
34317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34323 if (!SWIG_IsOK(res2)) {
34324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
34325 }
34326 arg2 = reinterpret_cast< wxWindow * >(argp2);
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (bool)(arg1)->Reparent(arg2);
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 {
34334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34335 }
34336 return resultobj;
34337 fail:
34338 return NULL;
34339 }
34340
34341
34342 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34343 PyObject *resultobj = 0;
34344 wxWindow *arg1 = (wxWindow *) 0 ;
34345 wxWindow *arg2 = (wxWindow *) 0 ;
34346 void *argp1 = 0 ;
34347 int res1 = 0 ;
34348 void *argp2 = 0 ;
34349 int res2 = 0 ;
34350 PyObject * obj0 = 0 ;
34351 PyObject * obj1 = 0 ;
34352 char * kwnames[] = {
34353 (char *) "self",(char *) "child", NULL
34354 };
34355
34356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
34357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34358 if (!SWIG_IsOK(res1)) {
34359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34360 }
34361 arg1 = reinterpret_cast< wxWindow * >(argp1);
34362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34363 if (!SWIG_IsOK(res2)) {
34364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34365 }
34366 arg2 = reinterpret_cast< wxWindow * >(argp2);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 (arg1)->AddChild(arg2);
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_Py_Void();
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 wxWindow *arg2 = (wxWindow *) 0 ;
34384 void *argp1 = 0 ;
34385 int res1 = 0 ;
34386 void *argp2 = 0 ;
34387 int res2 = 0 ;
34388 PyObject * obj0 = 0 ;
34389 PyObject * obj1 = 0 ;
34390 char * kwnames[] = {
34391 (char *) "self",(char *) "child", NULL
34392 };
34393
34394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
34395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34396 if (!SWIG_IsOK(res1)) {
34397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
34398 }
34399 arg1 = reinterpret_cast< wxWindow * >(argp1);
34400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
34401 if (!SWIG_IsOK(res2)) {
34402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
34403 }
34404 arg2 = reinterpret_cast< wxWindow * >(argp2);
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 (arg1)->RemoveChild(arg2);
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 resultobj = SWIG_Py_Void();
34412 return resultobj;
34413 fail:
34414 return NULL;
34415 }
34416
34417
34418 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = 0;
34420 wxWindow *arg1 = (wxWindow *) 0 ;
34421 bool arg2 ;
34422 void *argp1 = 0 ;
34423 int res1 = 0 ;
34424 bool val2 ;
34425 int ecode2 = 0 ;
34426 PyObject * obj0 = 0 ;
34427 PyObject * obj1 = 0 ;
34428 char * kwnames[] = {
34429 (char *) "self",(char *) "on", NULL
34430 };
34431
34432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
34433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34434 if (!SWIG_IsOK(res1)) {
34435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
34436 }
34437 arg1 = reinterpret_cast< wxWindow * >(argp1);
34438 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34439 if (!SWIG_IsOK(ecode2)) {
34440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
34441 }
34442 arg2 = static_cast< bool >(val2);
34443 {
34444 PyThreadState* __tstate = wxPyBeginAllowThreads();
34445 (arg1)->SetDoubleBuffered(arg2);
34446 wxPyEndAllowThreads(__tstate);
34447 if (PyErr_Occurred()) SWIG_fail;
34448 }
34449 resultobj = SWIG_Py_Void();
34450 return resultobj;
34451 fail:
34452 return NULL;
34453 }
34454
34455
34456 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34457 PyObject *resultobj = 0;
34458 wxWindow *arg1 = (wxWindow *) 0 ;
34459 long arg2 ;
34460 wxWindow *result = 0 ;
34461 void *argp1 = 0 ;
34462 int res1 = 0 ;
34463 long val2 ;
34464 int ecode2 = 0 ;
34465 PyObject * obj0 = 0 ;
34466 PyObject * obj1 = 0 ;
34467 char * kwnames[] = {
34468 (char *) "self",(char *) "winid", NULL
34469 };
34470
34471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34473 if (!SWIG_IsOK(res1)) {
34474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34475 }
34476 arg1 = reinterpret_cast< wxWindow * >(argp1);
34477 ecode2 = SWIG_AsVal_long(obj1, &val2);
34478 if (!SWIG_IsOK(ecode2)) {
34479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34480 }
34481 arg2 = static_cast< long >(val2);
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 result = (wxWindow *)(arg1)->FindWindow(arg2);
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 {
34489 resultobj = wxPyMake_wxObject(result, 0);
34490 }
34491 return resultobj;
34492 fail:
34493 return NULL;
34494 }
34495
34496
34497 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34498 PyObject *resultobj = 0;
34499 wxWindow *arg1 = (wxWindow *) 0 ;
34500 wxString *arg2 = 0 ;
34501 wxWindow *result = 0 ;
34502 void *argp1 = 0 ;
34503 int res1 = 0 ;
34504 bool temp2 = false ;
34505 PyObject * obj0 = 0 ;
34506 PyObject * obj1 = 0 ;
34507 char * kwnames[] = {
34508 (char *) "self",(char *) "name", NULL
34509 };
34510
34511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34515 }
34516 arg1 = reinterpret_cast< wxWindow * >(argp1);
34517 {
34518 arg2 = wxString_in_helper(obj1);
34519 if (arg2 == NULL) SWIG_fail;
34520 temp2 = true;
34521 }
34522 {
34523 PyThreadState* __tstate = wxPyBeginAllowThreads();
34524 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34525 wxPyEndAllowThreads(__tstate);
34526 if (PyErr_Occurred()) SWIG_fail;
34527 }
34528 {
34529 resultobj = wxPyMake_wxObject(result, 0);
34530 }
34531 {
34532 if (temp2)
34533 delete arg2;
34534 }
34535 return resultobj;
34536 fail:
34537 {
34538 if (temp2)
34539 delete arg2;
34540 }
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34546 PyObject *resultobj = 0;
34547 wxWindow *arg1 = (wxWindow *) 0 ;
34548 wxEvtHandler *result = 0 ;
34549 void *argp1 = 0 ;
34550 int res1 = 0 ;
34551 PyObject *swig_obj[1] ;
34552
34553 if (!args) SWIG_fail;
34554 swig_obj[0] = args;
34555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34558 }
34559 arg1 = reinterpret_cast< wxWindow * >(argp1);
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 {
34567 resultobj = wxPyMake_wxObject(result, 0);
34568 }
34569 return resultobj;
34570 fail:
34571 return NULL;
34572 }
34573
34574
34575 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34576 PyObject *resultobj = 0;
34577 wxWindow *arg1 = (wxWindow *) 0 ;
34578 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34579 void *argp1 = 0 ;
34580 int res1 = 0 ;
34581 void *argp2 = 0 ;
34582 int res2 = 0 ;
34583 PyObject * obj0 = 0 ;
34584 PyObject * obj1 = 0 ;
34585 char * kwnames[] = {
34586 (char *) "self",(char *) "handler", NULL
34587 };
34588
34589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34596 if (!SWIG_IsOK(res2)) {
34597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34598 }
34599 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34600 {
34601 PyThreadState* __tstate = wxPyBeginAllowThreads();
34602 (arg1)->SetEventHandler(arg2);
34603 wxPyEndAllowThreads(__tstate);
34604 if (PyErr_Occurred()) SWIG_fail;
34605 }
34606 resultobj = SWIG_Py_Void();
34607 return resultobj;
34608 fail:
34609 return NULL;
34610 }
34611
34612
34613 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34614 PyObject *resultobj = 0;
34615 wxWindow *arg1 = (wxWindow *) 0 ;
34616 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34617 void *argp1 = 0 ;
34618 int res1 = 0 ;
34619 void *argp2 = 0 ;
34620 int res2 = 0 ;
34621 PyObject * obj0 = 0 ;
34622 PyObject * obj1 = 0 ;
34623 char * kwnames[] = {
34624 (char *) "self",(char *) "handler", NULL
34625 };
34626
34627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34629 if (!SWIG_IsOK(res1)) {
34630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34631 }
34632 arg1 = reinterpret_cast< wxWindow * >(argp1);
34633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34634 if (!SWIG_IsOK(res2)) {
34635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34636 }
34637 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 (arg1)->PushEventHandler(arg2);
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 resultobj = SWIG_Py_Void();
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxWindow *arg1 = (wxWindow *) 0 ;
34654 bool arg2 = (bool) false ;
34655 wxEvtHandler *result = 0 ;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 bool val2 ;
34659 int ecode2 = 0 ;
34660 PyObject * obj0 = 0 ;
34661 PyObject * obj1 = 0 ;
34662 char * kwnames[] = {
34663 (char *) "self",(char *) "deleteHandler", NULL
34664 };
34665
34666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 if (obj1) {
34673 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34674 if (!SWIG_IsOK(ecode2)) {
34675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34676 }
34677 arg2 = static_cast< bool >(val2);
34678 }
34679 {
34680 PyThreadState* __tstate = wxPyBeginAllowThreads();
34681 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34682 wxPyEndAllowThreads(__tstate);
34683 if (PyErr_Occurred()) SWIG_fail;
34684 }
34685 {
34686 resultobj = wxPyMake_wxObject(result, 0);
34687 }
34688 return resultobj;
34689 fail:
34690 return NULL;
34691 }
34692
34693
34694 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34695 PyObject *resultobj = 0;
34696 wxWindow *arg1 = (wxWindow *) 0 ;
34697 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34698 bool result;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 void *argp2 = 0 ;
34702 int res2 = 0 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "handler", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34713 }
34714 arg1 = reinterpret_cast< wxWindow * >(argp1);
34715 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34716 if (!SWIG_IsOK(res2)) {
34717 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34718 }
34719 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34720 {
34721 PyThreadState* __tstate = wxPyBeginAllowThreads();
34722 result = (bool)(arg1)->RemoveEventHandler(arg2);
34723 wxPyEndAllowThreads(__tstate);
34724 if (PyErr_Occurred()) SWIG_fail;
34725 }
34726 {
34727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34728 }
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34736 PyObject *resultobj = 0;
34737 wxWindow *arg1 = (wxWindow *) 0 ;
34738 wxValidator *arg2 = 0 ;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 void *argp2 = 0 ;
34742 int res2 = 0 ;
34743 PyObject * obj0 = 0 ;
34744 PyObject * obj1 = 0 ;
34745 char * kwnames[] = {
34746 (char *) "self",(char *) "validator", NULL
34747 };
34748
34749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34751 if (!SWIG_IsOK(res1)) {
34752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34753 }
34754 arg1 = reinterpret_cast< wxWindow * >(argp1);
34755 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34756 if (!SWIG_IsOK(res2)) {
34757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34758 }
34759 if (!argp2) {
34760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34761 }
34762 arg2 = reinterpret_cast< wxValidator * >(argp2);
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 (arg1)->SetValidator((wxValidator const &)*arg2);
34766 wxPyEndAllowThreads(__tstate);
34767 if (PyErr_Occurred()) SWIG_fail;
34768 }
34769 resultobj = SWIG_Py_Void();
34770 return resultobj;
34771 fail:
34772 return NULL;
34773 }
34774
34775
34776 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34777 PyObject *resultobj = 0;
34778 wxWindow *arg1 = (wxWindow *) 0 ;
34779 wxValidator *result = 0 ;
34780 void *argp1 = 0 ;
34781 int res1 = 0 ;
34782 PyObject *swig_obj[1] ;
34783
34784 if (!args) SWIG_fail;
34785 swig_obj[0] = args;
34786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34787 if (!SWIG_IsOK(res1)) {
34788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34789 }
34790 arg1 = reinterpret_cast< wxWindow * >(argp1);
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = (wxValidator *)(arg1)->GetValidator();
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 {
34798 resultobj = wxPyMake_wxObject(result, (bool)0);
34799 }
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34807 PyObject *resultobj = 0;
34808 wxWindow *arg1 = (wxWindow *) 0 ;
34809 bool result;
34810 void *argp1 = 0 ;
34811 int res1 = 0 ;
34812 PyObject *swig_obj[1] ;
34813
34814 if (!args) SWIG_fail;
34815 swig_obj[0] = args;
34816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34817 if (!SWIG_IsOK(res1)) {
34818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34819 }
34820 arg1 = reinterpret_cast< wxWindow * >(argp1);
34821 {
34822 PyThreadState* __tstate = wxPyBeginAllowThreads();
34823 result = (bool)(arg1)->Validate();
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_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34837 PyObject *resultobj = 0;
34838 wxWindow *arg1 = (wxWindow *) 0 ;
34839 bool result;
34840 void *argp1 = 0 ;
34841 int res1 = 0 ;
34842 PyObject *swig_obj[1] ;
34843
34844 if (!args) SWIG_fail;
34845 swig_obj[0] = args;
34846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34847 if (!SWIG_IsOK(res1)) {
34848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34849 }
34850 arg1 = reinterpret_cast< wxWindow * >(argp1);
34851 {
34852 PyThreadState* __tstate = wxPyBeginAllowThreads();
34853 result = (bool)(arg1)->TransferDataToWindow();
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 {
34858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxWindow *arg1 = (wxWindow *) 0 ;
34869 bool 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_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (bool)(arg1)->TransferDataFromWindow();
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 {
34888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34889 }
34890 return resultobj;
34891 fail:
34892 return NULL;
34893 }
34894
34895
34896 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34897 PyObject *resultobj = 0;
34898 wxWindow *arg1 = (wxWindow *) 0 ;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 PyObject *swig_obj[1] ;
34902
34903 if (!args) SWIG_fail;
34904 swig_obj[0] = args;
34905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34906 if (!SWIG_IsOK(res1)) {
34907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34908 }
34909 arg1 = reinterpret_cast< wxWindow * >(argp1);
34910 {
34911 PyThreadState* __tstate = wxPyBeginAllowThreads();
34912 (arg1)->InitDialog();
34913 wxPyEndAllowThreads(__tstate);
34914 if (PyErr_Occurred()) SWIG_fail;
34915 }
34916 resultobj = SWIG_Py_Void();
34917 return resultobj;
34918 fail:
34919 return NULL;
34920 }
34921
34922
34923 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34924 PyObject *resultobj = 0;
34925 wxWindow *arg1 = (wxWindow *) 0 ;
34926 wxAcceleratorTable *arg2 = 0 ;
34927 void *argp1 = 0 ;
34928 int res1 = 0 ;
34929 void *argp2 = 0 ;
34930 int res2 = 0 ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 char * kwnames[] = {
34934 (char *) "self",(char *) "accel", NULL
34935 };
34936
34937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34939 if (!SWIG_IsOK(res1)) {
34940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34941 }
34942 arg1 = reinterpret_cast< wxWindow * >(argp1);
34943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34944 if (!SWIG_IsOK(res2)) {
34945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34946 }
34947 if (!argp2) {
34948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34949 }
34950 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34951 {
34952 PyThreadState* __tstate = wxPyBeginAllowThreads();
34953 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34954 wxPyEndAllowThreads(__tstate);
34955 if (PyErr_Occurred()) SWIG_fail;
34956 }
34957 resultobj = SWIG_Py_Void();
34958 return resultobj;
34959 fail:
34960 return NULL;
34961 }
34962
34963
34964 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34965 PyObject *resultobj = 0;
34966 wxWindow *arg1 = (wxWindow *) 0 ;
34967 wxAcceleratorTable *result = 0 ;
34968 void *argp1 = 0 ;
34969 int res1 = 0 ;
34970 PyObject *swig_obj[1] ;
34971
34972 if (!args) SWIG_fail;
34973 swig_obj[0] = args;
34974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34975 if (!SWIG_IsOK(res1)) {
34976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34977 }
34978 arg1 = reinterpret_cast< wxWindow * >(argp1);
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxWindow *arg1 = (wxWindow *) 0 ;
34995 int arg2 ;
34996 int arg3 ;
34997 int arg4 ;
34998 bool result;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 int val2 ;
35002 int ecode2 = 0 ;
35003 int val3 ;
35004 int ecode3 = 0 ;
35005 int val4 ;
35006 int ecode4 = 0 ;
35007 PyObject * obj0 = 0 ;
35008 PyObject * obj1 = 0 ;
35009 PyObject * obj2 = 0 ;
35010 PyObject * obj3 = 0 ;
35011 char * kwnames[] = {
35012 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
35013 };
35014
35015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35019 }
35020 arg1 = reinterpret_cast< wxWindow * >(argp1);
35021 ecode2 = SWIG_AsVal_int(obj1, &val2);
35022 if (!SWIG_IsOK(ecode2)) {
35023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
35024 }
35025 arg2 = static_cast< int >(val2);
35026 ecode3 = SWIG_AsVal_int(obj2, &val3);
35027 if (!SWIG_IsOK(ecode3)) {
35028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
35029 }
35030 arg3 = static_cast< int >(val3);
35031 ecode4 = SWIG_AsVal_int(obj3, &val4);
35032 if (!SWIG_IsOK(ecode4)) {
35033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
35034 }
35035 arg4 = static_cast< int >(val4);
35036 {
35037 PyThreadState* __tstate = wxPyBeginAllowThreads();
35038 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
35039 wxPyEndAllowThreads(__tstate);
35040 if (PyErr_Occurred()) SWIG_fail;
35041 }
35042 {
35043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35044 }
35045 return resultobj;
35046 fail:
35047 return NULL;
35048 }
35049
35050
35051 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35052 PyObject *resultobj = 0;
35053 wxWindow *arg1 = (wxWindow *) 0 ;
35054 int arg2 ;
35055 bool result;
35056 void *argp1 = 0 ;
35057 int res1 = 0 ;
35058 int val2 ;
35059 int ecode2 = 0 ;
35060 PyObject * obj0 = 0 ;
35061 PyObject * obj1 = 0 ;
35062 char * kwnames[] = {
35063 (char *) "self",(char *) "hotkeyId", NULL
35064 };
35065
35066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
35067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35068 if (!SWIG_IsOK(res1)) {
35069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
35070 }
35071 arg1 = reinterpret_cast< wxWindow * >(argp1);
35072 ecode2 = SWIG_AsVal_int(obj1, &val2);
35073 if (!SWIG_IsOK(ecode2)) {
35074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
35075 }
35076 arg2 = static_cast< int >(val2);
35077 {
35078 PyThreadState* __tstate = wxPyBeginAllowThreads();
35079 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
35080 wxPyEndAllowThreads(__tstate);
35081 if (PyErr_Occurred()) SWIG_fail;
35082 }
35083 {
35084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35085 }
35086 return resultobj;
35087 fail:
35088 return NULL;
35089 }
35090
35091
35092 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35093 PyObject *resultobj = 0;
35094 wxWindow *arg1 = (wxWindow *) 0 ;
35095 wxPoint *arg2 = 0 ;
35096 wxPoint result;
35097 void *argp1 = 0 ;
35098 int res1 = 0 ;
35099 wxPoint temp2 ;
35100 PyObject * obj0 = 0 ;
35101 PyObject * obj1 = 0 ;
35102 char * kwnames[] = {
35103 (char *) "self",(char *) "pt", NULL
35104 };
35105
35106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35108 if (!SWIG_IsOK(res1)) {
35109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35110 }
35111 arg1 = reinterpret_cast< wxWindow * >(argp1);
35112 {
35113 arg2 = &temp2;
35114 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35115 }
35116 {
35117 PyThreadState* __tstate = wxPyBeginAllowThreads();
35118 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35119 wxPyEndAllowThreads(__tstate);
35120 if (PyErr_Occurred()) SWIG_fail;
35121 }
35122 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35123 return resultobj;
35124 fail:
35125 return NULL;
35126 }
35127
35128
35129 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35130 PyObject *resultobj = 0;
35131 wxWindow *arg1 = (wxWindow *) 0 ;
35132 wxSize *arg2 = 0 ;
35133 wxSize result;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 wxSize temp2 ;
35137 PyObject * obj0 = 0 ;
35138 PyObject * obj1 = 0 ;
35139 char * kwnames[] = {
35140 (char *) "self",(char *) "sz", NULL
35141 };
35142
35143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
35144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 arg2 = &temp2;
35151 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35152 }
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35156 wxPyEndAllowThreads(__tstate);
35157 if (PyErr_Occurred()) SWIG_fail;
35158 }
35159 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35160 return resultobj;
35161 fail:
35162 return NULL;
35163 }
35164
35165
35166 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35167 PyObject *resultobj = 0;
35168 wxWindow *arg1 = (wxWindow *) 0 ;
35169 wxPoint *arg2 = 0 ;
35170 wxPoint result;
35171 void *argp1 = 0 ;
35172 int res1 = 0 ;
35173 wxPoint temp2 ;
35174 PyObject * obj0 = 0 ;
35175 PyObject * obj1 = 0 ;
35176 char * kwnames[] = {
35177 (char *) "self",(char *) "pt", NULL
35178 };
35179
35180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
35181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 {
35187 arg2 = &temp2;
35188 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35189 }
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 wxSize *arg2 = 0 ;
35207 wxSize result;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 wxSize temp2 ;
35211 PyObject * obj0 = 0 ;
35212 PyObject * obj1 = 0 ;
35213 char * kwnames[] = {
35214 (char *) "self",(char *) "sz", NULL
35215 };
35216
35217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
35218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35219 if (!SWIG_IsOK(res1)) {
35220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
35221 }
35222 arg1 = reinterpret_cast< wxWindow * >(argp1);
35223 {
35224 arg2 = &temp2;
35225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj = 0;
35242 wxWindow *arg1 = (wxWindow *) 0 ;
35243 wxPoint *arg2 = 0 ;
35244 wxPoint result;
35245 void *argp1 = 0 ;
35246 int res1 = 0 ;
35247 wxPoint temp2 ;
35248 PyObject * obj0 = 0 ;
35249 PyObject * obj1 = 0 ;
35250 char * kwnames[] = {
35251 (char *) "self",(char *) "pt", NULL
35252 };
35253
35254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35258 }
35259 arg1 = reinterpret_cast< wxWindow * >(argp1);
35260 {
35261 arg2 = &temp2;
35262 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35263 }
35264 {
35265 PyThreadState* __tstate = wxPyBeginAllowThreads();
35266 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
35267 wxPyEndAllowThreads(__tstate);
35268 if (PyErr_Occurred()) SWIG_fail;
35269 }
35270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35271 return resultobj;
35272 fail:
35273 return NULL;
35274 }
35275
35276
35277 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35278 PyObject *resultobj = 0;
35279 wxWindow *arg1 = (wxWindow *) 0 ;
35280 wxSize *arg2 = 0 ;
35281 wxSize result;
35282 void *argp1 = 0 ;
35283 int res1 = 0 ;
35284 wxSize temp2 ;
35285 PyObject * obj0 = 0 ;
35286 PyObject * obj1 = 0 ;
35287 char * kwnames[] = {
35288 (char *) "self",(char *) "sz", NULL
35289 };
35290
35291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
35292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35293 if (!SWIG_IsOK(res1)) {
35294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
35295 }
35296 arg1 = reinterpret_cast< wxWindow * >(argp1);
35297 {
35298 arg2 = &temp2;
35299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35300 }
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 int arg2 ;
35318 int arg3 ;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 int val2 ;
35322 int ecode2 = 0 ;
35323 int val3 ;
35324 int ecode3 = 0 ;
35325 PyObject * obj0 = 0 ;
35326 PyObject * obj1 = 0 ;
35327 PyObject * obj2 = 0 ;
35328 char * kwnames[] = {
35329 (char *) "self",(char *) "x",(char *) "y", NULL
35330 };
35331
35332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35334 if (!SWIG_IsOK(res1)) {
35335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
35336 }
35337 arg1 = reinterpret_cast< wxWindow * >(argp1);
35338 ecode2 = SWIG_AsVal_int(obj1, &val2);
35339 if (!SWIG_IsOK(ecode2)) {
35340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
35341 }
35342 arg2 = static_cast< int >(val2);
35343 ecode3 = SWIG_AsVal_int(obj2, &val3);
35344 if (!SWIG_IsOK(ecode3)) {
35345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
35346 }
35347 arg3 = static_cast< int >(val3);
35348 {
35349 PyThreadState* __tstate = wxPyBeginAllowThreads();
35350 (arg1)->WarpPointer(arg2,arg3);
35351 wxPyEndAllowThreads(__tstate);
35352 if (PyErr_Occurred()) SWIG_fail;
35353 }
35354 resultobj = SWIG_Py_Void();
35355 return resultobj;
35356 fail:
35357 return NULL;
35358 }
35359
35360
35361 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35362 PyObject *resultobj = 0;
35363 wxWindow *arg1 = (wxWindow *) 0 ;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 PyObject *swig_obj[1] ;
35367
35368 if (!args) SWIG_fail;
35369 swig_obj[0] = args;
35370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35373 }
35374 arg1 = reinterpret_cast< wxWindow * >(argp1);
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->CaptureMouse();
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_Py_Void();
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35389 PyObject *resultobj = 0;
35390 wxWindow *arg1 = (wxWindow *) 0 ;
35391 void *argp1 = 0 ;
35392 int res1 = 0 ;
35393 PyObject *swig_obj[1] ;
35394
35395 if (!args) SWIG_fail;
35396 swig_obj[0] = args;
35397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35398 if (!SWIG_IsOK(res1)) {
35399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
35400 }
35401 arg1 = reinterpret_cast< wxWindow * >(argp1);
35402 {
35403 PyThreadState* __tstate = wxPyBeginAllowThreads();
35404 (arg1)->ReleaseMouse();
35405 wxPyEndAllowThreads(__tstate);
35406 if (PyErr_Occurred()) SWIG_fail;
35407 }
35408 resultobj = SWIG_Py_Void();
35409 return resultobj;
35410 fail:
35411 return NULL;
35412 }
35413
35414
35415 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35416 PyObject *resultobj = 0;
35417 wxWindow *result = 0 ;
35418
35419 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
35420 {
35421 if (!wxPyCheckForApp()) SWIG_fail;
35422 PyThreadState* __tstate = wxPyBeginAllowThreads();
35423 result = (wxWindow *)wxWindow::GetCapture();
35424 wxPyEndAllowThreads(__tstate);
35425 if (PyErr_Occurred()) SWIG_fail;
35426 }
35427 {
35428 resultobj = wxPyMake_wxObject(result, 0);
35429 }
35430 return resultobj;
35431 fail:
35432 return NULL;
35433 }
35434
35435
35436 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35437 PyObject *resultobj = 0;
35438 wxWindow *arg1 = (wxWindow *) 0 ;
35439 bool result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 PyObject *swig_obj[1] ;
35443
35444 if (!args) SWIG_fail;
35445 swig_obj[0] = args;
35446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35447 if (!SWIG_IsOK(res1)) {
35448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
35449 }
35450 arg1 = reinterpret_cast< wxWindow * >(argp1);
35451 {
35452 PyThreadState* __tstate = wxPyBeginAllowThreads();
35453 result = (bool)((wxWindow const *)arg1)->HasCapture();
35454 wxPyEndAllowThreads(__tstate);
35455 if (PyErr_Occurred()) SWIG_fail;
35456 }
35457 {
35458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35459 }
35460 return resultobj;
35461 fail:
35462 return NULL;
35463 }
35464
35465
35466 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35467 PyObject *resultobj = 0;
35468 wxWindow *arg1 = (wxWindow *) 0 ;
35469 bool arg2 = (bool) true ;
35470 wxRect *arg3 = (wxRect *) NULL ;
35471 void *argp1 = 0 ;
35472 int res1 = 0 ;
35473 bool val2 ;
35474 int ecode2 = 0 ;
35475 void *argp3 = 0 ;
35476 int res3 = 0 ;
35477 PyObject * obj0 = 0 ;
35478 PyObject * obj1 = 0 ;
35479 PyObject * obj2 = 0 ;
35480 char * kwnames[] = {
35481 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35482 };
35483
35484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35486 if (!SWIG_IsOK(res1)) {
35487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35488 }
35489 arg1 = reinterpret_cast< wxWindow * >(argp1);
35490 if (obj1) {
35491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35492 if (!SWIG_IsOK(ecode2)) {
35493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35494 }
35495 arg2 = static_cast< bool >(val2);
35496 }
35497 if (obj2) {
35498 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35499 if (!SWIG_IsOK(res3)) {
35500 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35501 }
35502 arg3 = reinterpret_cast< wxRect * >(argp3);
35503 }
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 resultobj = SWIG_Py_Void();
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj = 0;
35519 wxWindow *arg1 = (wxWindow *) 0 ;
35520 wxRect *arg2 = 0 ;
35521 bool arg3 = (bool) true ;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 wxRect temp2 ;
35525 bool val3 ;
35526 int ecode3 = 0 ;
35527 PyObject * obj0 = 0 ;
35528 PyObject * obj1 = 0 ;
35529 PyObject * obj2 = 0 ;
35530 char * kwnames[] = {
35531 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35532 };
35533
35534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35536 if (!SWIG_IsOK(res1)) {
35537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35538 }
35539 arg1 = reinterpret_cast< wxWindow * >(argp1);
35540 {
35541 arg2 = &temp2;
35542 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35543 }
35544 if (obj2) {
35545 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35546 if (!SWIG_IsOK(ecode3)) {
35547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35548 }
35549 arg3 = static_cast< bool >(val3);
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 resultobj = SWIG_Py_Void();
35558 return resultobj;
35559 fail:
35560 return NULL;
35561 }
35562
35563
35564 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35565 PyObject *resultobj = 0;
35566 wxWindow *arg1 = (wxWindow *) 0 ;
35567 void *argp1 = 0 ;
35568 int res1 = 0 ;
35569 PyObject *swig_obj[1] ;
35570
35571 if (!args) SWIG_fail;
35572 swig_obj[0] = args;
35573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 (arg1)->Update();
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 resultobj = SWIG_Py_Void();
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35592 PyObject *resultobj = 0;
35593 wxWindow *arg1 = (wxWindow *) 0 ;
35594 void *argp1 = 0 ;
35595 int res1 = 0 ;
35596 PyObject *swig_obj[1] ;
35597
35598 if (!args) SWIG_fail;
35599 swig_obj[0] = args;
35600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35601 if (!SWIG_IsOK(res1)) {
35602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35603 }
35604 arg1 = reinterpret_cast< wxWindow * >(argp1);
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 (arg1)->ClearBackground();
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 resultobj = SWIG_Py_Void();
35612 return resultobj;
35613 fail:
35614 return NULL;
35615 }
35616
35617
35618 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35619 PyObject *resultobj = 0;
35620 wxWindow *arg1 = (wxWindow *) 0 ;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 PyObject *swig_obj[1] ;
35624
35625 if (!args) SWIG_fail;
35626 swig_obj[0] = args;
35627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35628 if (!SWIG_IsOK(res1)) {
35629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35630 }
35631 arg1 = reinterpret_cast< wxWindow * >(argp1);
35632 {
35633 PyThreadState* __tstate = wxPyBeginAllowThreads();
35634 (arg1)->Freeze();
35635 wxPyEndAllowThreads(__tstate);
35636 if (PyErr_Occurred()) SWIG_fail;
35637 }
35638 resultobj = SWIG_Py_Void();
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxWindow *arg1 = (wxWindow *) 0 ;
35648 bool result;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35658 }
35659 arg1 = reinterpret_cast< wxWindow * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 {
35667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35676 PyObject *resultobj = 0;
35677 wxWindow *arg1 = (wxWindow *) 0 ;
35678 void *argp1 = 0 ;
35679 int res1 = 0 ;
35680 PyObject *swig_obj[1] ;
35681
35682 if (!args) SWIG_fail;
35683 swig_obj[0] = args;
35684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 (arg1)->Thaw();
35692 wxPyEndAllowThreads(__tstate);
35693 if (PyErr_Occurred()) SWIG_fail;
35694 }
35695 resultobj = SWIG_Py_Void();
35696 return resultobj;
35697 fail:
35698 return NULL;
35699 }
35700
35701
35702 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35703 PyObject *resultobj = 0;
35704 wxWindow *arg1 = (wxWindow *) 0 ;
35705 wxDC *arg2 = 0 ;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 void *argp2 = 0 ;
35709 int res2 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 char * kwnames[] = {
35713 (char *) "self",(char *) "dc", NULL
35714 };
35715
35716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35723 if (!SWIG_IsOK(res2)) {
35724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35725 }
35726 if (!argp2) {
35727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35728 }
35729 arg2 = reinterpret_cast< wxDC * >(argp2);
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 (arg1)->PrepareDC(*arg2);
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 resultobj = SWIG_Py_Void();
35737 return resultobj;
35738 fail:
35739 return NULL;
35740 }
35741
35742
35743 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35744 PyObject *resultobj = 0;
35745 wxWindow *arg1 = (wxWindow *) 0 ;
35746 bool result;
35747 void *argp1 = 0 ;
35748 int res1 = 0 ;
35749 PyObject *swig_obj[1] ;
35750
35751 if (!args) SWIG_fail;
35752 swig_obj[0] = args;
35753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35754 if (!SWIG_IsOK(res1)) {
35755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
35756 }
35757 arg1 = reinterpret_cast< wxWindow * >(argp1);
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 {
35765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35766 }
35767 return resultobj;
35768 fail:
35769 return NULL;
35770 }
35771
35772
35773 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35774 PyObject *resultobj = 0;
35775 wxWindow *arg1 = (wxWindow *) 0 ;
35776 wxRegion *result = 0 ;
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_wxWindow, 0 | 0 );
35784 if (!SWIG_IsOK(res1)) {
35785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35786 }
35787 arg1 = reinterpret_cast< wxWindow * >(argp1);
35788 {
35789 PyThreadState* __tstate = wxPyBeginAllowThreads();
35790 {
35791 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35792 result = (wxRegion *) &_result_ref;
35793 }
35794 wxPyEndAllowThreads(__tstate);
35795 if (PyErr_Occurred()) SWIG_fail;
35796 }
35797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35798 return resultobj;
35799 fail:
35800 return NULL;
35801 }
35802
35803
35804 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35805 PyObject *resultobj = 0;
35806 wxWindow *arg1 = (wxWindow *) 0 ;
35807 wxRect result;
35808 void *argp1 = 0 ;
35809 int res1 = 0 ;
35810 PyObject *swig_obj[1] ;
35811
35812 if (!args) SWIG_fail;
35813 swig_obj[0] = args;
35814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35815 if (!SWIG_IsOK(res1)) {
35816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35817 }
35818 arg1 = reinterpret_cast< wxWindow * >(argp1);
35819 {
35820 PyThreadState* __tstate = wxPyBeginAllowThreads();
35821 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35822 wxPyEndAllowThreads(__tstate);
35823 if (PyErr_Occurred()) SWIG_fail;
35824 }
35825 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35826 return resultobj;
35827 fail:
35828 return NULL;
35829 }
35830
35831
35832 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35833 PyObject *resultobj = 0;
35834 wxWindow *arg1 = (wxWindow *) 0 ;
35835 int arg2 ;
35836 int arg3 ;
35837 int arg4 = (int) 1 ;
35838 int arg5 = (int) 1 ;
35839 bool result;
35840 void *argp1 = 0 ;
35841 int res1 = 0 ;
35842 int val2 ;
35843 int ecode2 = 0 ;
35844 int val3 ;
35845 int ecode3 = 0 ;
35846 int val4 ;
35847 int ecode4 = 0 ;
35848 int val5 ;
35849 int ecode5 = 0 ;
35850 PyObject * obj0 = 0 ;
35851 PyObject * obj1 = 0 ;
35852 PyObject * obj2 = 0 ;
35853 PyObject * obj3 = 0 ;
35854 PyObject * obj4 = 0 ;
35855 char * kwnames[] = {
35856 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35857 };
35858
35859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35861 if (!SWIG_IsOK(res1)) {
35862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35863 }
35864 arg1 = reinterpret_cast< wxWindow * >(argp1);
35865 ecode2 = SWIG_AsVal_int(obj1, &val2);
35866 if (!SWIG_IsOK(ecode2)) {
35867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35868 }
35869 arg2 = static_cast< int >(val2);
35870 ecode3 = SWIG_AsVal_int(obj2, &val3);
35871 if (!SWIG_IsOK(ecode3)) {
35872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35873 }
35874 arg3 = static_cast< int >(val3);
35875 if (obj3) {
35876 ecode4 = SWIG_AsVal_int(obj3, &val4);
35877 if (!SWIG_IsOK(ecode4)) {
35878 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35879 }
35880 arg4 = static_cast< int >(val4);
35881 }
35882 if (obj4) {
35883 ecode5 = SWIG_AsVal_int(obj4, &val5);
35884 if (!SWIG_IsOK(ecode5)) {
35885 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35886 }
35887 arg5 = static_cast< int >(val5);
35888 }
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 wxPoint *arg2 = 0 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 wxPoint temp2 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "pt", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 {
35925 arg2 = &temp2;
35926 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35927 }
35928 {
35929 PyThreadState* __tstate = wxPyBeginAllowThreads();
35930 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35931 wxPyEndAllowThreads(__tstate);
35932 if (PyErr_Occurred()) SWIG_fail;
35933 }
35934 {
35935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35936 }
35937 return resultobj;
35938 fail:
35939 return NULL;
35940 }
35941
35942
35943 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35944 PyObject *resultobj = 0;
35945 wxWindow *arg1 = (wxWindow *) 0 ;
35946 wxRect *arg2 = 0 ;
35947 bool result;
35948 void *argp1 = 0 ;
35949 int res1 = 0 ;
35950 wxRect temp2 ;
35951 PyObject * obj0 = 0 ;
35952 PyObject * obj1 = 0 ;
35953 char * kwnames[] = {
35954 (char *) "self",(char *) "rect", NULL
35955 };
35956
35957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35959 if (!SWIG_IsOK(res1)) {
35960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35961 }
35962 arg1 = reinterpret_cast< wxWindow * >(argp1);
35963 {
35964 arg2 = &temp2;
35965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35966 }
35967 {
35968 PyThreadState* __tstate = wxPyBeginAllowThreads();
35969 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35970 wxPyEndAllowThreads(__tstate);
35971 if (PyErr_Occurred()) SWIG_fail;
35972 }
35973 {
35974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35975 }
35976 return resultobj;
35977 fail:
35978 return NULL;
35979 }
35980
35981
35982 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35983 PyObject *resultobj = 0;
35984 wxWindow *arg1 = (wxWindow *) 0 ;
35985 SwigValueWrapper<wxVisualAttributes > result;
35986 void *argp1 = 0 ;
35987 int res1 = 0 ;
35988 PyObject *swig_obj[1] ;
35989
35990 if (!args) SWIG_fail;
35991 swig_obj[0] = args;
35992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35993 if (!SWIG_IsOK(res1)) {
35994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35995 }
35996 arg1 = reinterpret_cast< wxWindow * >(argp1);
35997 {
35998 PyThreadState* __tstate = wxPyBeginAllowThreads();
35999 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
36000 wxPyEndAllowThreads(__tstate);
36001 if (PyErr_Occurred()) SWIG_fail;
36002 }
36003 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36004 return resultobj;
36005 fail:
36006 return NULL;
36007 }
36008
36009
36010 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36011 PyObject *resultobj = 0;
36012 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36013 SwigValueWrapper<wxVisualAttributes > result;
36014 int val1 ;
36015 int ecode1 = 0 ;
36016 PyObject * obj0 = 0 ;
36017 char * kwnames[] = {
36018 (char *) "variant", NULL
36019 };
36020
36021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
36022 if (obj0) {
36023 ecode1 = SWIG_AsVal_int(obj0, &val1);
36024 if (!SWIG_IsOK(ecode1)) {
36025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
36026 }
36027 arg1 = static_cast< wxWindowVariant >(val1);
36028 }
36029 {
36030 if (!wxPyCheckForApp()) SWIG_fail;
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 result = wxWindow::GetClassDefaultAttributes(arg1);
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36044 PyObject *resultobj = 0;
36045 wxWindow *arg1 = (wxWindow *) 0 ;
36046 wxColour *arg2 = 0 ;
36047 bool result;
36048 void *argp1 = 0 ;
36049 int res1 = 0 ;
36050 wxColour temp2 ;
36051 PyObject * obj0 = 0 ;
36052 PyObject * obj1 = 0 ;
36053 char * kwnames[] = {
36054 (char *) "self",(char *) "colour", NULL
36055 };
36056
36057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36061 }
36062 arg1 = reinterpret_cast< wxWindow * >(argp1);
36063 {
36064 arg2 = &temp2;
36065 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36066 }
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 {
36074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36075 }
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 wxColour *arg2 = 0 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 wxColour temp2 ;
36089 PyObject * obj0 = 0 ;
36090 PyObject * obj1 = 0 ;
36091 char * kwnames[] = {
36092 (char *) "self",(char *) "colour", NULL
36093 };
36094
36095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36099 }
36100 arg1 = reinterpret_cast< wxWindow * >(argp1);
36101 {
36102 arg2 = &temp2;
36103 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36104 }
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 resultobj = SWIG_Py_Void();
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36119 PyObject *resultobj = 0;
36120 wxWindow *arg1 = (wxWindow *) 0 ;
36121 wxColour *arg2 = 0 ;
36122 bool result;
36123 void *argp1 = 0 ;
36124 int res1 = 0 ;
36125 wxColour temp2 ;
36126 PyObject * obj0 = 0 ;
36127 PyObject * obj1 = 0 ;
36128 char * kwnames[] = {
36129 (char *) "self",(char *) "colour", NULL
36130 };
36131
36132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36134 if (!SWIG_IsOK(res1)) {
36135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36136 }
36137 arg1 = reinterpret_cast< wxWindow * >(argp1);
36138 {
36139 arg2 = &temp2;
36140 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36141 }
36142 {
36143 PyThreadState* __tstate = wxPyBeginAllowThreads();
36144 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
36145 wxPyEndAllowThreads(__tstate);
36146 if (PyErr_Occurred()) SWIG_fail;
36147 }
36148 {
36149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36150 }
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj = 0;
36159 wxWindow *arg1 = (wxWindow *) 0 ;
36160 wxColour *arg2 = 0 ;
36161 void *argp1 = 0 ;
36162 int res1 = 0 ;
36163 wxColour temp2 ;
36164 PyObject * obj0 = 0 ;
36165 PyObject * obj1 = 0 ;
36166 char * kwnames[] = {
36167 (char *) "self",(char *) "colour", NULL
36168 };
36169
36170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
36171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36172 if (!SWIG_IsOK(res1)) {
36173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
36174 }
36175 arg1 = reinterpret_cast< wxWindow * >(argp1);
36176 {
36177 arg2 = &temp2;
36178 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36179 }
36180 {
36181 PyThreadState* __tstate = wxPyBeginAllowThreads();
36182 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
36183 wxPyEndAllowThreads(__tstate);
36184 if (PyErr_Occurred()) SWIG_fail;
36185 }
36186 resultobj = SWIG_Py_Void();
36187 return resultobj;
36188 fail:
36189 return NULL;
36190 }
36191
36192
36193 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36194 PyObject *resultobj = 0;
36195 wxWindow *arg1 = (wxWindow *) 0 ;
36196 wxColour result;
36197 void *argp1 = 0 ;
36198 int res1 = 0 ;
36199 PyObject *swig_obj[1] ;
36200
36201 if (!args) SWIG_fail;
36202 swig_obj[0] = args;
36203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36206 }
36207 arg1 = reinterpret_cast< wxWindow * >(argp1);
36208 {
36209 PyThreadState* __tstate = wxPyBeginAllowThreads();
36210 result = ((wxWindow const *)arg1)->GetBackgroundColour();
36211 wxPyEndAllowThreads(__tstate);
36212 if (PyErr_Occurred()) SWIG_fail;
36213 }
36214 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36215 return resultobj;
36216 fail:
36217 return NULL;
36218 }
36219
36220
36221 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36222 PyObject *resultobj = 0;
36223 wxWindow *arg1 = (wxWindow *) 0 ;
36224 wxColour result;
36225 void *argp1 = 0 ;
36226 int res1 = 0 ;
36227 PyObject *swig_obj[1] ;
36228
36229 if (!args) SWIG_fail;
36230 swig_obj[0] = args;
36231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36232 if (!SWIG_IsOK(res1)) {
36233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36234 }
36235 arg1 = reinterpret_cast< wxWindow * >(argp1);
36236 {
36237 PyThreadState* __tstate = wxPyBeginAllowThreads();
36238 result = ((wxWindow const *)arg1)->GetForegroundColour();
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
36243 return resultobj;
36244 fail:
36245 return NULL;
36246 }
36247
36248
36249 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36250 PyObject *resultobj = 0;
36251 wxWindow *arg1 = (wxWindow *) 0 ;
36252 bool result;
36253 void *argp1 = 0 ;
36254 int res1 = 0 ;
36255 PyObject *swig_obj[1] ;
36256
36257 if (!args) SWIG_fail;
36258 swig_obj[0] = args;
36259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36260 if (!SWIG_IsOK(res1)) {
36261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
36262 }
36263 arg1 = reinterpret_cast< wxWindow * >(argp1);
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
36267 wxPyEndAllowThreads(__tstate);
36268 if (PyErr_Occurred()) SWIG_fail;
36269 }
36270 {
36271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36272 }
36273 return resultobj;
36274 fail:
36275 return NULL;
36276 }
36277
36278
36279 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36280 PyObject *resultobj = 0;
36281 wxWindow *arg1 = (wxWindow *) 0 ;
36282 bool result;
36283 void *argp1 = 0 ;
36284 int res1 = 0 ;
36285 PyObject *swig_obj[1] ;
36286
36287 if (!args) SWIG_fail;
36288 swig_obj[0] = args;
36289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36290 if (!SWIG_IsOK(res1)) {
36291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
36292 }
36293 arg1 = reinterpret_cast< wxWindow * >(argp1);
36294 {
36295 PyThreadState* __tstate = wxPyBeginAllowThreads();
36296 result = (bool)((wxWindow const *)arg1)->UseBgCol();
36297 wxPyEndAllowThreads(__tstate);
36298 if (PyErr_Occurred()) SWIG_fail;
36299 }
36300 {
36301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36302 }
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36310 PyObject *resultobj = 0;
36311 wxWindow *arg1 = (wxWindow *) 0 ;
36312 wxBackgroundStyle arg2 ;
36313 bool result;
36314 void *argp1 = 0 ;
36315 int res1 = 0 ;
36316 int val2 ;
36317 int ecode2 = 0 ;
36318 PyObject * obj0 = 0 ;
36319 PyObject * obj1 = 0 ;
36320 char * kwnames[] = {
36321 (char *) "self",(char *) "style", NULL
36322 };
36323
36324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36326 if (!SWIG_IsOK(res1)) {
36327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36328 }
36329 arg1 = reinterpret_cast< wxWindow * >(argp1);
36330 ecode2 = SWIG_AsVal_int(obj1, &val2);
36331 if (!SWIG_IsOK(ecode2)) {
36332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
36333 }
36334 arg2 = static_cast< wxBackgroundStyle >(val2);
36335 {
36336 PyThreadState* __tstate = wxPyBeginAllowThreads();
36337 result = (bool)(arg1)->SetBackgroundStyle(arg2);
36338 wxPyEndAllowThreads(__tstate);
36339 if (PyErr_Occurred()) SWIG_fail;
36340 }
36341 {
36342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36343 }
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36351 PyObject *resultobj = 0;
36352 wxWindow *arg1 = (wxWindow *) 0 ;
36353 wxBackgroundStyle result;
36354 void *argp1 = 0 ;
36355 int res1 = 0 ;
36356 PyObject *swig_obj[1] ;
36357
36358 if (!args) SWIG_fail;
36359 swig_obj[0] = args;
36360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36361 if (!SWIG_IsOK(res1)) {
36362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36363 }
36364 arg1 = reinterpret_cast< wxWindow * >(argp1);
36365 {
36366 PyThreadState* __tstate = wxPyBeginAllowThreads();
36367 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
36368 wxPyEndAllowThreads(__tstate);
36369 if (PyErr_Occurred()) SWIG_fail;
36370 }
36371 resultobj = SWIG_From_int(static_cast< int >(result));
36372 return resultobj;
36373 fail:
36374 return NULL;
36375 }
36376
36377
36378 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36379 PyObject *resultobj = 0;
36380 wxWindow *arg1 = (wxWindow *) 0 ;
36381 bool result;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 PyObject *swig_obj[1] ;
36385
36386 if (!args) SWIG_fail;
36387 swig_obj[0] = args;
36388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36389 if (!SWIG_IsOK(res1)) {
36390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
36391 }
36392 arg1 = reinterpret_cast< wxWindow * >(argp1);
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 result = (bool)(arg1)->HasTransparentBackground();
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 {
36400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36401 }
36402 return resultobj;
36403 fail:
36404 return NULL;
36405 }
36406
36407
36408 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36409 PyObject *resultobj = 0;
36410 wxWindow *arg1 = (wxWindow *) 0 ;
36411 wxCursor *arg2 = 0 ;
36412 bool result;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 void *argp2 = 0 ;
36416 int res2 = 0 ;
36417 PyObject * obj0 = 0 ;
36418 PyObject * obj1 = 0 ;
36419 char * kwnames[] = {
36420 (char *) "self",(char *) "cursor", NULL
36421 };
36422
36423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36427 }
36428 arg1 = reinterpret_cast< wxWindow * >(argp1);
36429 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
36430 if (!SWIG_IsOK(res2)) {
36431 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36432 }
36433 if (!argp2) {
36434 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
36435 }
36436 arg2 = reinterpret_cast< wxCursor * >(argp2);
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 {
36444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36445 }
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36453 PyObject *resultobj = 0;
36454 wxWindow *arg1 = (wxWindow *) 0 ;
36455 wxCursor result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 PyObject *swig_obj[1] ;
36459
36460 if (!args) SWIG_fail;
36461 swig_obj[0] = args;
36462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36463 if (!SWIG_IsOK(res1)) {
36464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
36465 }
36466 arg1 = reinterpret_cast< wxWindow * >(argp1);
36467 {
36468 PyThreadState* __tstate = wxPyBeginAllowThreads();
36469 result = (arg1)->GetCursor();
36470 wxPyEndAllowThreads(__tstate);
36471 if (PyErr_Occurred()) SWIG_fail;
36472 }
36473 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
36474 return resultobj;
36475 fail:
36476 return NULL;
36477 }
36478
36479
36480 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36481 PyObject *resultobj = 0;
36482 wxWindow *arg1 = (wxWindow *) 0 ;
36483 wxFont *arg2 = 0 ;
36484 bool result;
36485 void *argp1 = 0 ;
36486 int res1 = 0 ;
36487 void *argp2 = 0 ;
36488 int res2 = 0 ;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 char * kwnames[] = {
36492 (char *) "self",(char *) "font", NULL
36493 };
36494
36495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36497 if (!SWIG_IsOK(res1)) {
36498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36499 }
36500 arg1 = reinterpret_cast< wxWindow * >(argp1);
36501 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36502 if (!SWIG_IsOK(res2)) {
36503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36504 }
36505 if (!argp2) {
36506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36507 }
36508 arg2 = reinterpret_cast< wxFont * >(argp2);
36509 {
36510 PyThreadState* __tstate = wxPyBeginAllowThreads();
36511 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36512 wxPyEndAllowThreads(__tstate);
36513 if (PyErr_Occurred()) SWIG_fail;
36514 }
36515 {
36516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36517 }
36518 return resultobj;
36519 fail:
36520 return NULL;
36521 }
36522
36523
36524 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36525 PyObject *resultobj = 0;
36526 wxWindow *arg1 = (wxWindow *) 0 ;
36527 wxFont *arg2 = 0 ;
36528 void *argp1 = 0 ;
36529 int res1 = 0 ;
36530 void *argp2 = 0 ;
36531 int res2 = 0 ;
36532 PyObject * obj0 = 0 ;
36533 PyObject * obj1 = 0 ;
36534 char * kwnames[] = {
36535 (char *) "self",(char *) "font", NULL
36536 };
36537
36538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36540 if (!SWIG_IsOK(res1)) {
36541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36542 }
36543 arg1 = reinterpret_cast< wxWindow * >(argp1);
36544 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36545 if (!SWIG_IsOK(res2)) {
36546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36547 }
36548 if (!argp2) {
36549 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36550 }
36551 arg2 = reinterpret_cast< wxFont * >(argp2);
36552 {
36553 PyThreadState* __tstate = wxPyBeginAllowThreads();
36554 (arg1)->SetOwnFont((wxFont const &)*arg2);
36555 wxPyEndAllowThreads(__tstate);
36556 if (PyErr_Occurred()) SWIG_fail;
36557 }
36558 resultobj = SWIG_Py_Void();
36559 return resultobj;
36560 fail:
36561 return NULL;
36562 }
36563
36564
36565 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36566 PyObject *resultobj = 0;
36567 wxWindow *arg1 = (wxWindow *) 0 ;
36568 wxFont result;
36569 void *argp1 = 0 ;
36570 int res1 = 0 ;
36571 PyObject *swig_obj[1] ;
36572
36573 if (!args) SWIG_fail;
36574 swig_obj[0] = args;
36575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 {
36581 PyThreadState* __tstate = wxPyBeginAllowThreads();
36582 result = (arg1)->GetFont();
36583 wxPyEndAllowThreads(__tstate);
36584 if (PyErr_Occurred()) SWIG_fail;
36585 }
36586 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36587 return resultobj;
36588 fail:
36589 return NULL;
36590 }
36591
36592
36593 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36594 PyObject *resultobj = 0;
36595 wxWindow *arg1 = (wxWindow *) 0 ;
36596 wxCaret *arg2 = (wxCaret *) 0 ;
36597 void *argp1 = 0 ;
36598 int res1 = 0 ;
36599 int res2 = 0 ;
36600 PyObject * obj0 = 0 ;
36601 PyObject * obj1 = 0 ;
36602 char * kwnames[] = {
36603 (char *) "self",(char *) "caret", NULL
36604 };
36605
36606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36613 if (!SWIG_IsOK(res2)) {
36614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36615 }
36616 {
36617 PyThreadState* __tstate = wxPyBeginAllowThreads();
36618 (arg1)->SetCaret(arg2);
36619 wxPyEndAllowThreads(__tstate);
36620 if (PyErr_Occurred()) SWIG_fail;
36621 }
36622 resultobj = SWIG_Py_Void();
36623 return resultobj;
36624 fail:
36625 return NULL;
36626 }
36627
36628
36629 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36630 PyObject *resultobj = 0;
36631 wxWindow *arg1 = (wxWindow *) 0 ;
36632 wxCaret *result = 0 ;
36633 void *argp1 = 0 ;
36634 int res1 = 0 ;
36635 PyObject *swig_obj[1] ;
36636
36637 if (!args) SWIG_fail;
36638 swig_obj[0] = args;
36639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36640 if (!SWIG_IsOK(res1)) {
36641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36642 }
36643 arg1 = reinterpret_cast< wxWindow * >(argp1);
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 int result;
36661 void *argp1 = 0 ;
36662 int res1 = 0 ;
36663 PyObject *swig_obj[1] ;
36664
36665 if (!args) SWIG_fail;
36666 swig_obj[0] = args;
36667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36668 if (!SWIG_IsOK(res1)) {
36669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36670 }
36671 arg1 = reinterpret_cast< wxWindow * >(argp1);
36672 {
36673 PyThreadState* __tstate = wxPyBeginAllowThreads();
36674 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36675 wxPyEndAllowThreads(__tstate);
36676 if (PyErr_Occurred()) SWIG_fail;
36677 }
36678 resultobj = SWIG_From_int(static_cast< int >(result));
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36686 PyObject *resultobj = 0;
36687 wxWindow *arg1 = (wxWindow *) 0 ;
36688 int result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 PyObject *swig_obj[1] ;
36692
36693 if (!args) SWIG_fail;
36694 swig_obj[0] = args;
36695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36698 }
36699 arg1 = reinterpret_cast< wxWindow * >(argp1);
36700 {
36701 PyThreadState* __tstate = wxPyBeginAllowThreads();
36702 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36703 wxPyEndAllowThreads(__tstate);
36704 if (PyErr_Occurred()) SWIG_fail;
36705 }
36706 resultobj = SWIG_From_int(static_cast< int >(result));
36707 return resultobj;
36708 fail:
36709 return NULL;
36710 }
36711
36712
36713 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36714 PyObject *resultobj = 0;
36715 wxWindow *arg1 = (wxWindow *) 0 ;
36716 wxString *arg2 = 0 ;
36717 int *arg3 = (int *) 0 ;
36718 int *arg4 = (int *) 0 ;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721 bool temp2 = false ;
36722 int temp3 ;
36723 int res3 = SWIG_TMPOBJ ;
36724 int temp4 ;
36725 int res4 = SWIG_TMPOBJ ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "string", NULL
36730 };
36731
36732 arg3 = &temp3;
36733 arg4 = &temp4;
36734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36736 if (!SWIG_IsOK(res1)) {
36737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36738 }
36739 arg1 = reinterpret_cast< wxWindow * >(argp1);
36740 {
36741 arg2 = wxString_in_helper(obj1);
36742 if (arg2 == NULL) SWIG_fail;
36743 temp2 = true;
36744 }
36745 {
36746 PyThreadState* __tstate = wxPyBeginAllowThreads();
36747 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36748 wxPyEndAllowThreads(__tstate);
36749 if (PyErr_Occurred()) SWIG_fail;
36750 }
36751 resultobj = SWIG_Py_Void();
36752 if (SWIG_IsTmpObj(res3)) {
36753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36754 } else {
36755 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36757 }
36758 if (SWIG_IsTmpObj(res4)) {
36759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36760 } else {
36761 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36763 }
36764 {
36765 if (temp2)
36766 delete arg2;
36767 }
36768 return resultobj;
36769 fail:
36770 {
36771 if (temp2)
36772 delete arg2;
36773 }
36774 return NULL;
36775 }
36776
36777
36778 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36779 PyObject *resultobj = 0;
36780 wxWindow *arg1 = (wxWindow *) 0 ;
36781 wxString *arg2 = 0 ;
36782 int *arg3 = (int *) 0 ;
36783 int *arg4 = (int *) 0 ;
36784 int *arg5 = (int *) 0 ;
36785 int *arg6 = (int *) 0 ;
36786 wxFont *arg7 = (wxFont *) NULL ;
36787 void *argp1 = 0 ;
36788 int res1 = 0 ;
36789 bool temp2 = false ;
36790 int temp3 ;
36791 int res3 = SWIG_TMPOBJ ;
36792 int temp4 ;
36793 int res4 = SWIG_TMPOBJ ;
36794 int temp5 ;
36795 int res5 = SWIG_TMPOBJ ;
36796 int temp6 ;
36797 int res6 = SWIG_TMPOBJ ;
36798 void *argp7 = 0 ;
36799 int res7 = 0 ;
36800 PyObject * obj0 = 0 ;
36801 PyObject * obj1 = 0 ;
36802 PyObject * obj2 = 0 ;
36803 char * kwnames[] = {
36804 (char *) "self",(char *) "string",(char *) "font", NULL
36805 };
36806
36807 arg3 = &temp3;
36808 arg4 = &temp4;
36809 arg5 = &temp5;
36810 arg6 = &temp6;
36811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36813 if (!SWIG_IsOK(res1)) {
36814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36815 }
36816 arg1 = reinterpret_cast< wxWindow * >(argp1);
36817 {
36818 arg2 = wxString_in_helper(obj1);
36819 if (arg2 == NULL) SWIG_fail;
36820 temp2 = true;
36821 }
36822 if (obj2) {
36823 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36824 if (!SWIG_IsOK(res7)) {
36825 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36826 }
36827 arg7 = reinterpret_cast< wxFont * >(argp7);
36828 }
36829 {
36830 PyThreadState* __tstate = wxPyBeginAllowThreads();
36831 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 resultobj = SWIG_Py_Void();
36836 if (SWIG_IsTmpObj(res3)) {
36837 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36838 } else {
36839 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36840 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36841 }
36842 if (SWIG_IsTmpObj(res4)) {
36843 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36844 } else {
36845 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36847 }
36848 if (SWIG_IsTmpObj(res5)) {
36849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36850 } else {
36851 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36853 }
36854 if (SWIG_IsTmpObj(res6)) {
36855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36856 } else {
36857 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36859 }
36860 {
36861 if (temp2)
36862 delete arg2;
36863 }
36864 return resultobj;
36865 fail:
36866 {
36867 if (temp2)
36868 delete arg2;
36869 }
36870 return NULL;
36871 }
36872
36873
36874 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36875 PyObject *resultobj = 0;
36876 wxWindow *arg1 = (wxWindow *) 0 ;
36877 int *arg2 = (int *) 0 ;
36878 int *arg3 = (int *) 0 ;
36879 void *argp1 = 0 ;
36880 int res1 = 0 ;
36881 int temp2 ;
36882 int res2 = 0 ;
36883 int temp3 ;
36884 int res3 = 0 ;
36885 PyObject * obj0 = 0 ;
36886 PyObject * obj1 = 0 ;
36887 PyObject * obj2 = 0 ;
36888 char * kwnames[] = {
36889 (char *) "self",(char *) "x",(char *) "y", NULL
36890 };
36891
36892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36899 int val;
36900 int ecode = SWIG_AsVal_int(obj1, &val);
36901 if (!SWIG_IsOK(ecode)) {
36902 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36903 }
36904 temp2 = static_cast< int >(val);
36905 arg2 = &temp2;
36906 res2 = SWIG_AddTmpMask(ecode);
36907 }
36908 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36909 int val;
36910 int ecode = SWIG_AsVal_int(obj2, &val);
36911 if (!SWIG_IsOK(ecode)) {
36912 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36913 }
36914 temp3 = static_cast< int >(val);
36915 arg3 = &temp3;
36916 res3 = SWIG_AddTmpMask(ecode);
36917 }
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 resultobj = SWIG_Py_Void();
36925 if (SWIG_IsTmpObj(res2)) {
36926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36927 } else {
36928 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36930 }
36931 if (SWIG_IsTmpObj(res3)) {
36932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36933 } else {
36934 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36936 }
36937 return resultobj;
36938 fail:
36939 return NULL;
36940 }
36941
36942
36943 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36944 PyObject *resultobj = 0;
36945 wxWindow *arg1 = (wxWindow *) 0 ;
36946 int *arg2 = (int *) 0 ;
36947 int *arg3 = (int *) 0 ;
36948 void *argp1 = 0 ;
36949 int res1 = 0 ;
36950 int temp2 ;
36951 int res2 = 0 ;
36952 int temp3 ;
36953 int res3 = 0 ;
36954 PyObject * obj0 = 0 ;
36955 PyObject * obj1 = 0 ;
36956 PyObject * obj2 = 0 ;
36957 char * kwnames[] = {
36958 (char *) "self",(char *) "x",(char *) "y", NULL
36959 };
36960
36961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36963 if (!SWIG_IsOK(res1)) {
36964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36965 }
36966 arg1 = reinterpret_cast< wxWindow * >(argp1);
36967 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36968 int val;
36969 int ecode = SWIG_AsVal_int(obj1, &val);
36970 if (!SWIG_IsOK(ecode)) {
36971 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36972 }
36973 temp2 = static_cast< int >(val);
36974 arg2 = &temp2;
36975 res2 = SWIG_AddTmpMask(ecode);
36976 }
36977 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36978 int val;
36979 int ecode = SWIG_AsVal_int(obj2, &val);
36980 if (!SWIG_IsOK(ecode)) {
36981 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36982 }
36983 temp3 = static_cast< int >(val);
36984 arg3 = &temp3;
36985 res3 = SWIG_AddTmpMask(ecode);
36986 }
36987 {
36988 PyThreadState* __tstate = wxPyBeginAllowThreads();
36989 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36990 wxPyEndAllowThreads(__tstate);
36991 if (PyErr_Occurred()) SWIG_fail;
36992 }
36993 resultobj = SWIG_Py_Void();
36994 if (SWIG_IsTmpObj(res2)) {
36995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36996 } else {
36997 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36999 }
37000 if (SWIG_IsTmpObj(res3)) {
37001 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
37002 } else {
37003 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
37004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
37005 }
37006 return resultobj;
37007 fail:
37008 return NULL;
37009 }
37010
37011
37012 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37013 PyObject *resultobj = 0;
37014 wxWindow *arg1 = (wxWindow *) 0 ;
37015 wxPoint *arg2 = 0 ;
37016 wxPoint result;
37017 void *argp1 = 0 ;
37018 int res1 = 0 ;
37019 wxPoint temp2 ;
37020 PyObject * obj0 = 0 ;
37021 PyObject * obj1 = 0 ;
37022 char * kwnames[] = {
37023 (char *) "self",(char *) "pt", NULL
37024 };
37025
37026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
37027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 {
37033 arg2 = &temp2;
37034 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37035 }
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 wxPoint *arg2 = 0 ;
37053 wxPoint result;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 wxPoint temp2 ;
37057 PyObject * obj0 = 0 ;
37058 PyObject * obj1 = 0 ;
37059 char * kwnames[] = {
37060 (char *) "self",(char *) "pt", NULL
37061 };
37062
37063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
37064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37065 if (!SWIG_IsOK(res1)) {
37066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
37067 }
37068 arg1 = reinterpret_cast< wxWindow * >(argp1);
37069 {
37070 arg2 = &temp2;
37071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37072 }
37073 {
37074 PyThreadState* __tstate = wxPyBeginAllowThreads();
37075 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
37076 wxPyEndAllowThreads(__tstate);
37077 if (PyErr_Occurred()) SWIG_fail;
37078 }
37079 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37080 return resultobj;
37081 fail:
37082 return NULL;
37083 }
37084
37085
37086 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37087 PyObject *resultobj = 0;
37088 wxWindow *arg1 = (wxWindow *) 0 ;
37089 int arg2 ;
37090 int arg3 ;
37091 wxHitTest result;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 int val2 ;
37095 int ecode2 = 0 ;
37096 int val3 ;
37097 int ecode3 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 PyObject * obj2 = 0 ;
37101 char * kwnames[] = {
37102 (char *) "self",(char *) "x",(char *) "y", NULL
37103 };
37104
37105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
37109 }
37110 arg1 = reinterpret_cast< wxWindow * >(argp1);
37111 ecode2 = SWIG_AsVal_int(obj1, &val2);
37112 if (!SWIG_IsOK(ecode2)) {
37113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
37114 }
37115 arg2 = static_cast< int >(val2);
37116 ecode3 = SWIG_AsVal_int(obj2, &val3);
37117 if (!SWIG_IsOK(ecode3)) {
37118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
37119 }
37120 arg3 = static_cast< int >(val3);
37121 {
37122 PyThreadState* __tstate = wxPyBeginAllowThreads();
37123 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 resultobj = SWIG_From_int(static_cast< int >(result));
37128 return resultobj;
37129 fail:
37130 return NULL;
37131 }
37132
37133
37134 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37135 PyObject *resultobj = 0;
37136 wxWindow *arg1 = (wxWindow *) 0 ;
37137 wxPoint *arg2 = 0 ;
37138 wxHitTest result;
37139 void *argp1 = 0 ;
37140 int res1 = 0 ;
37141 wxPoint temp2 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 char * kwnames[] = {
37145 (char *) "self",(char *) "pt", NULL
37146 };
37147
37148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
37149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
37152 }
37153 arg1 = reinterpret_cast< wxWindow * >(argp1);
37154 {
37155 arg2 = &temp2;
37156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37157 }
37158 {
37159 PyThreadState* __tstate = wxPyBeginAllowThreads();
37160 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
37161 wxPyEndAllowThreads(__tstate);
37162 if (PyErr_Occurred()) SWIG_fail;
37163 }
37164 resultobj = SWIG_From_int(static_cast< int >(result));
37165 return resultobj;
37166 fail:
37167 return NULL;
37168 }
37169
37170
37171 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37172 PyObject *resultobj = 0;
37173 wxWindow *arg1 = (wxWindow *) 0 ;
37174 long arg2 ;
37175 wxBorder result;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 long val2 ;
37179 int ecode2 = 0 ;
37180
37181 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
37182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37183 if (!SWIG_IsOK(res1)) {
37184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37185 }
37186 arg1 = reinterpret_cast< wxWindow * >(argp1);
37187 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
37188 if (!SWIG_IsOK(ecode2)) {
37189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
37190 }
37191 arg2 = static_cast< long >(val2);
37192 {
37193 PyThreadState* __tstate = wxPyBeginAllowThreads();
37194 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 resultobj = SWIG_From_int(static_cast< int >(result));
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
37206 PyObject *resultobj = 0;
37207 wxWindow *arg1 = (wxWindow *) 0 ;
37208 wxBorder result;
37209 void *argp1 = 0 ;
37210 int res1 = 0 ;
37211
37212 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
37213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 resultobj = SWIG_From_int(static_cast< int >(result));
37225 return resultobj;
37226 fail:
37227 return NULL;
37228 }
37229
37230
37231 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
37232 int argc;
37233 PyObject *argv[3];
37234
37235 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
37236 --argc;
37237 if (argc == 1) {
37238 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
37239 }
37240 if (argc == 2) {
37241 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
37242 }
37243
37244 fail:
37245 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
37246 return NULL;
37247 }
37248
37249
37250 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37251 PyObject *resultobj = 0;
37252 wxWindow *arg1 = (wxWindow *) 0 ;
37253 long arg2 = (long) wxUPDATE_UI_NONE ;
37254 void *argp1 = 0 ;
37255 int res1 = 0 ;
37256 long val2 ;
37257 int ecode2 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 char * kwnames[] = {
37261 (char *) "self",(char *) "flags", NULL
37262 };
37263
37264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
37265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37266 if (!SWIG_IsOK(res1)) {
37267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
37268 }
37269 arg1 = reinterpret_cast< wxWindow * >(argp1);
37270 if (obj1) {
37271 ecode2 = SWIG_AsVal_long(obj1, &val2);
37272 if (!SWIG_IsOK(ecode2)) {
37273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
37274 }
37275 arg2 = static_cast< long >(val2);
37276 }
37277 {
37278 PyThreadState* __tstate = wxPyBeginAllowThreads();
37279 (arg1)->UpdateWindowUI(arg2);
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 resultobj = SWIG_Py_Void();
37284 return resultobj;
37285 fail:
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37291 PyObject *resultobj = 0;
37292 wxWindow *arg1 = (wxWindow *) 0 ;
37293 wxMenu *arg2 = (wxMenu *) 0 ;
37294 int arg3 = (int) -1 ;
37295 int arg4 = (int) -1 ;
37296 bool result;
37297 void *argp1 = 0 ;
37298 int res1 = 0 ;
37299 void *argp2 = 0 ;
37300 int res2 = 0 ;
37301 int val3 ;
37302 int ecode3 = 0 ;
37303 int val4 ;
37304 int ecode4 = 0 ;
37305 PyObject * obj0 = 0 ;
37306 PyObject * obj1 = 0 ;
37307 PyObject * obj2 = 0 ;
37308 PyObject * obj3 = 0 ;
37309 char * kwnames[] = {
37310 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
37311 };
37312
37313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37315 if (!SWIG_IsOK(res1)) {
37316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
37317 }
37318 arg1 = reinterpret_cast< wxWindow * >(argp1);
37319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37320 if (!SWIG_IsOK(res2)) {
37321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
37322 }
37323 arg2 = reinterpret_cast< wxMenu * >(argp2);
37324 if (obj2) {
37325 ecode3 = SWIG_AsVal_int(obj2, &val3);
37326 if (!SWIG_IsOK(ecode3)) {
37327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
37328 }
37329 arg3 = static_cast< int >(val3);
37330 }
37331 if (obj3) {
37332 ecode4 = SWIG_AsVal_int(obj3, &val4);
37333 if (!SWIG_IsOK(ecode4)) {
37334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
37335 }
37336 arg4 = static_cast< int >(val4);
37337 }
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 {
37345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37346 }
37347 return resultobj;
37348 fail:
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37354 PyObject *resultobj = 0;
37355 wxWindow *arg1 = (wxWindow *) 0 ;
37356 wxMenu *arg2 = (wxMenu *) 0 ;
37357 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37358 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37359 bool result;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 void *argp2 = 0 ;
37363 int res2 = 0 ;
37364 wxPoint temp3 ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 PyObject * obj2 = 0 ;
37368 char * kwnames[] = {
37369 (char *) "self",(char *) "menu",(char *) "pos", NULL
37370 };
37371
37372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
37379 if (!SWIG_IsOK(res2)) {
37380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
37381 }
37382 arg2 = reinterpret_cast< wxMenu * >(argp2);
37383 if (obj2) {
37384 {
37385 arg3 = &temp3;
37386 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37387 }
37388 }
37389 {
37390 PyThreadState* __tstate = wxPyBeginAllowThreads();
37391 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
37392 wxPyEndAllowThreads(__tstate);
37393 if (PyErr_Occurred()) SWIG_fail;
37394 }
37395 {
37396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37397 }
37398 return resultobj;
37399 fail:
37400 return NULL;
37401 }
37402
37403
37404 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37405 PyObject *resultobj = 0;
37406 wxWindow *arg1 = (wxWindow *) 0 ;
37407 bool result;
37408 void *argp1 = 0 ;
37409 int res1 = 0 ;
37410 PyObject *swig_obj[1] ;
37411
37412 if (!args) SWIG_fail;
37413 swig_obj[0] = args;
37414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37415 if (!SWIG_IsOK(res1)) {
37416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
37417 }
37418 arg1 = reinterpret_cast< wxWindow * >(argp1);
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 {
37426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37427 }
37428 return resultobj;
37429 fail:
37430 return NULL;
37431 }
37432
37433
37434 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37435 PyObject *resultobj = 0;
37436 wxWindow *arg1 = (wxWindow *) 0 ;
37437 long result;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 PyObject *swig_obj[1] ;
37441
37442 if (!args) SWIG_fail;
37443 swig_obj[0] = args;
37444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37447 }
37448 arg1 = reinterpret_cast< wxWindow * >(argp1);
37449 {
37450 PyThreadState* __tstate = wxPyBeginAllowThreads();
37451 result = (long)wxWindow_GetHandle(arg1);
37452 wxPyEndAllowThreads(__tstate);
37453 if (PyErr_Occurred()) SWIG_fail;
37454 }
37455 resultobj = SWIG_From_long(static_cast< long >(result));
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37463 PyObject *resultobj = 0;
37464 wxWindow *arg1 = (wxWindow *) 0 ;
37465 long arg2 ;
37466 void *argp1 = 0 ;
37467 int res1 = 0 ;
37468 long val2 ;
37469 int ecode2 = 0 ;
37470 PyObject * obj0 = 0 ;
37471 PyObject * obj1 = 0 ;
37472 char * kwnames[] = {
37473 (char *) "self",(char *) "handle", NULL
37474 };
37475
37476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
37477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37478 if (!SWIG_IsOK(res1)) {
37479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37480 }
37481 arg1 = reinterpret_cast< wxWindow * >(argp1);
37482 ecode2 = SWIG_AsVal_long(obj1, &val2);
37483 if (!SWIG_IsOK(ecode2)) {
37484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
37485 }
37486 arg2 = static_cast< long >(val2);
37487 {
37488 PyThreadState* __tstate = wxPyBeginAllowThreads();
37489 wxWindow_AssociateHandle(arg1,arg2);
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 resultobj = SWIG_Py_Void();
37494 return resultobj;
37495 fail:
37496 return NULL;
37497 }
37498
37499
37500 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37501 PyObject *resultobj = 0;
37502 wxWindow *arg1 = (wxWindow *) 0 ;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 PyObject *swig_obj[1] ;
37506
37507 if (!args) SWIG_fail;
37508 swig_obj[0] = args;
37509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 (arg1)->DissociateHandle();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 resultobj = SWIG_Py_Void();
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj = 0;
37529 wxWindow *arg1 = (wxWindow *) 0 ;
37530 int arg2 ;
37531 bool result;
37532 void *argp1 = 0 ;
37533 int res1 = 0 ;
37534 int val2 ;
37535 int ecode2 = 0 ;
37536 PyObject * obj0 = 0 ;
37537 PyObject * obj1 = 0 ;
37538 char * kwnames[] = {
37539 (char *) "self",(char *) "orient", NULL
37540 };
37541
37542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37544 if (!SWIG_IsOK(res1)) {
37545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37546 }
37547 arg1 = reinterpret_cast< wxWindow * >(argp1);
37548 ecode2 = SWIG_AsVal_int(obj1, &val2);
37549 if (!SWIG_IsOK(ecode2)) {
37550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37551 }
37552 arg2 = static_cast< int >(val2);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 int arg2 ;
37572 int arg3 ;
37573 int arg4 ;
37574 int arg5 ;
37575 bool arg6 = (bool) true ;
37576 void *argp1 = 0 ;
37577 int res1 = 0 ;
37578 int val2 ;
37579 int ecode2 = 0 ;
37580 int val3 ;
37581 int ecode3 = 0 ;
37582 int val4 ;
37583 int ecode4 = 0 ;
37584 int val5 ;
37585 int ecode5 = 0 ;
37586 bool val6 ;
37587 int ecode6 = 0 ;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 PyObject * obj2 = 0 ;
37591 PyObject * obj3 = 0 ;
37592 PyObject * obj4 = 0 ;
37593 PyObject * obj5 = 0 ;
37594 char * kwnames[] = {
37595 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37596 };
37597
37598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37600 if (!SWIG_IsOK(res1)) {
37601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37602 }
37603 arg1 = reinterpret_cast< wxWindow * >(argp1);
37604 ecode2 = SWIG_AsVal_int(obj1, &val2);
37605 if (!SWIG_IsOK(ecode2)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37607 }
37608 arg2 = static_cast< int >(val2);
37609 ecode3 = SWIG_AsVal_int(obj2, &val3);
37610 if (!SWIG_IsOK(ecode3)) {
37611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37612 }
37613 arg3 = static_cast< int >(val3);
37614 ecode4 = SWIG_AsVal_int(obj3, &val4);
37615 if (!SWIG_IsOK(ecode4)) {
37616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37617 }
37618 arg4 = static_cast< int >(val4);
37619 ecode5 = SWIG_AsVal_int(obj4, &val5);
37620 if (!SWIG_IsOK(ecode5)) {
37621 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37622 }
37623 arg5 = static_cast< int >(val5);
37624 if (obj5) {
37625 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37626 if (!SWIG_IsOK(ecode6)) {
37627 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37628 }
37629 arg6 = static_cast< bool >(val6);
37630 }
37631 {
37632 PyThreadState* __tstate = wxPyBeginAllowThreads();
37633 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37634 wxPyEndAllowThreads(__tstate);
37635 if (PyErr_Occurred()) SWIG_fail;
37636 }
37637 resultobj = SWIG_Py_Void();
37638 return resultobj;
37639 fail:
37640 return NULL;
37641 }
37642
37643
37644 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37645 PyObject *resultobj = 0;
37646 wxWindow *arg1 = (wxWindow *) 0 ;
37647 int arg2 ;
37648 int arg3 ;
37649 bool arg4 = (bool) true ;
37650 void *argp1 = 0 ;
37651 int res1 = 0 ;
37652 int val2 ;
37653 int ecode2 = 0 ;
37654 int val3 ;
37655 int ecode3 = 0 ;
37656 bool val4 ;
37657 int ecode4 = 0 ;
37658 PyObject * obj0 = 0 ;
37659 PyObject * obj1 = 0 ;
37660 PyObject * obj2 = 0 ;
37661 PyObject * obj3 = 0 ;
37662 char * kwnames[] = {
37663 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37664 };
37665
37666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37668 if (!SWIG_IsOK(res1)) {
37669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37670 }
37671 arg1 = reinterpret_cast< wxWindow * >(argp1);
37672 ecode2 = SWIG_AsVal_int(obj1, &val2);
37673 if (!SWIG_IsOK(ecode2)) {
37674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37675 }
37676 arg2 = static_cast< int >(val2);
37677 ecode3 = SWIG_AsVal_int(obj2, &val3);
37678 if (!SWIG_IsOK(ecode3)) {
37679 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37680 }
37681 arg3 = static_cast< int >(val3);
37682 if (obj3) {
37683 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37684 if (!SWIG_IsOK(ecode4)) {
37685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37686 }
37687 arg4 = static_cast< bool >(val4);
37688 }
37689 {
37690 PyThreadState* __tstate = wxPyBeginAllowThreads();
37691 (arg1)->SetScrollPos(arg2,arg3,arg4);
37692 wxPyEndAllowThreads(__tstate);
37693 if (PyErr_Occurred()) SWIG_fail;
37694 }
37695 resultobj = SWIG_Py_Void();
37696 return resultobj;
37697 fail:
37698 return NULL;
37699 }
37700
37701
37702 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37703 PyObject *resultobj = 0;
37704 wxWindow *arg1 = (wxWindow *) 0 ;
37705 int arg2 ;
37706 int result;
37707 void *argp1 = 0 ;
37708 int res1 = 0 ;
37709 int val2 ;
37710 int ecode2 = 0 ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char * kwnames[] = {
37714 (char *) "self",(char *) "orientation", NULL
37715 };
37716
37717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37719 if (!SWIG_IsOK(res1)) {
37720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37721 }
37722 arg1 = reinterpret_cast< wxWindow * >(argp1);
37723 ecode2 = SWIG_AsVal_int(obj1, &val2);
37724 if (!SWIG_IsOK(ecode2)) {
37725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37726 }
37727 arg2 = static_cast< int >(val2);
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37731 wxPyEndAllowThreads(__tstate);
37732 if (PyErr_Occurred()) SWIG_fail;
37733 }
37734 resultobj = SWIG_From_int(static_cast< int >(result));
37735 return resultobj;
37736 fail:
37737 return NULL;
37738 }
37739
37740
37741 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37742 PyObject *resultobj = 0;
37743 wxWindow *arg1 = (wxWindow *) 0 ;
37744 int arg2 ;
37745 int result;
37746 void *argp1 = 0 ;
37747 int res1 = 0 ;
37748 int val2 ;
37749 int ecode2 = 0 ;
37750 PyObject * obj0 = 0 ;
37751 PyObject * obj1 = 0 ;
37752 char * kwnames[] = {
37753 (char *) "self",(char *) "orientation", NULL
37754 };
37755
37756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37760 }
37761 arg1 = reinterpret_cast< wxWindow * >(argp1);
37762 ecode2 = SWIG_AsVal_int(obj1, &val2);
37763 if (!SWIG_IsOK(ecode2)) {
37764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37765 }
37766 arg2 = static_cast< int >(val2);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 resultobj = SWIG_From_int(static_cast< int >(result));
37774 return resultobj;
37775 fail:
37776 return NULL;
37777 }
37778
37779
37780 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37781 PyObject *resultobj = 0;
37782 wxWindow *arg1 = (wxWindow *) 0 ;
37783 int arg2 ;
37784 int result;
37785 void *argp1 = 0 ;
37786 int res1 = 0 ;
37787 int val2 ;
37788 int ecode2 = 0 ;
37789 PyObject * obj0 = 0 ;
37790 PyObject * obj1 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "self",(char *) "orientation", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37799 }
37800 arg1 = reinterpret_cast< wxWindow * >(argp1);
37801 ecode2 = SWIG_AsVal_int(obj1, &val2);
37802 if (!SWIG_IsOK(ecode2)) {
37803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37804 }
37805 arg2 = static_cast< int >(val2);
37806 {
37807 PyThreadState* __tstate = wxPyBeginAllowThreads();
37808 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37809 wxPyEndAllowThreads(__tstate);
37810 if (PyErr_Occurred()) SWIG_fail;
37811 }
37812 resultobj = SWIG_From_int(static_cast< int >(result));
37813 return resultobj;
37814 fail:
37815 return NULL;
37816 }
37817
37818
37819 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37820 PyObject *resultobj = 0;
37821 wxWindow *arg1 = (wxWindow *) 0 ;
37822 int arg2 ;
37823 int arg3 ;
37824 wxRect *arg4 = (wxRect *) NULL ;
37825 void *argp1 = 0 ;
37826 int res1 = 0 ;
37827 int val2 ;
37828 int ecode2 = 0 ;
37829 int val3 ;
37830 int ecode3 = 0 ;
37831 void *argp4 = 0 ;
37832 int res4 = 0 ;
37833 PyObject * obj0 = 0 ;
37834 PyObject * obj1 = 0 ;
37835 PyObject * obj2 = 0 ;
37836 PyObject * obj3 = 0 ;
37837 char * kwnames[] = {
37838 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37839 };
37840
37841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37843 if (!SWIG_IsOK(res1)) {
37844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37845 }
37846 arg1 = reinterpret_cast< wxWindow * >(argp1);
37847 ecode2 = SWIG_AsVal_int(obj1, &val2);
37848 if (!SWIG_IsOK(ecode2)) {
37849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37850 }
37851 arg2 = static_cast< int >(val2);
37852 ecode3 = SWIG_AsVal_int(obj2, &val3);
37853 if (!SWIG_IsOK(ecode3)) {
37854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37855 }
37856 arg3 = static_cast< int >(val3);
37857 if (obj3) {
37858 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37859 if (!SWIG_IsOK(res4)) {
37860 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37861 }
37862 arg4 = reinterpret_cast< wxRect * >(argp4);
37863 }
37864 {
37865 PyThreadState* __tstate = wxPyBeginAllowThreads();
37866 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37867 wxPyEndAllowThreads(__tstate);
37868 if (PyErr_Occurred()) SWIG_fail;
37869 }
37870 resultobj = SWIG_Py_Void();
37871 return resultobj;
37872 fail:
37873 return NULL;
37874 }
37875
37876
37877 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37878 PyObject *resultobj = 0;
37879 wxWindow *arg1 = (wxWindow *) 0 ;
37880 int arg2 ;
37881 bool result;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 int val2 ;
37885 int ecode2 = 0 ;
37886 PyObject * obj0 = 0 ;
37887 PyObject * obj1 = 0 ;
37888 char * kwnames[] = {
37889 (char *) "self",(char *) "lines", NULL
37890 };
37891
37892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37894 if (!SWIG_IsOK(res1)) {
37895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37896 }
37897 arg1 = reinterpret_cast< wxWindow * >(argp1);
37898 ecode2 = SWIG_AsVal_int(obj1, &val2);
37899 if (!SWIG_IsOK(ecode2)) {
37900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37901 }
37902 arg2 = static_cast< int >(val2);
37903 {
37904 PyThreadState* __tstate = wxPyBeginAllowThreads();
37905 result = (bool)(arg1)->ScrollLines(arg2);
37906 wxPyEndAllowThreads(__tstate);
37907 if (PyErr_Occurred()) SWIG_fail;
37908 }
37909 {
37910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37911 }
37912 return resultobj;
37913 fail:
37914 return NULL;
37915 }
37916
37917
37918 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37919 PyObject *resultobj = 0;
37920 wxWindow *arg1 = (wxWindow *) 0 ;
37921 int arg2 ;
37922 bool result;
37923 void *argp1 = 0 ;
37924 int res1 = 0 ;
37925 int val2 ;
37926 int ecode2 = 0 ;
37927 PyObject * obj0 = 0 ;
37928 PyObject * obj1 = 0 ;
37929 char * kwnames[] = {
37930 (char *) "self",(char *) "pages", NULL
37931 };
37932
37933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res1)) {
37936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37937 }
37938 arg1 = reinterpret_cast< wxWindow * >(argp1);
37939 ecode2 = SWIG_AsVal_int(obj1, &val2);
37940 if (!SWIG_IsOK(ecode2)) {
37941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37942 }
37943 arg2 = static_cast< int >(val2);
37944 {
37945 PyThreadState* __tstate = wxPyBeginAllowThreads();
37946 result = (bool)(arg1)->ScrollPages(arg2);
37947 wxPyEndAllowThreads(__tstate);
37948 if (PyErr_Occurred()) SWIG_fail;
37949 }
37950 {
37951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37952 }
37953 return resultobj;
37954 fail:
37955 return NULL;
37956 }
37957
37958
37959 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37960 PyObject *resultobj = 0;
37961 wxWindow *arg1 = (wxWindow *) 0 ;
37962 bool result;
37963 void *argp1 = 0 ;
37964 int res1 = 0 ;
37965 PyObject *swig_obj[1] ;
37966
37967 if (!args) SWIG_fail;
37968 swig_obj[0] = args;
37969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37970 if (!SWIG_IsOK(res1)) {
37971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37972 }
37973 arg1 = reinterpret_cast< wxWindow * >(argp1);
37974 {
37975 PyThreadState* __tstate = wxPyBeginAllowThreads();
37976 result = (bool)(arg1)->LineUp();
37977 wxPyEndAllowThreads(__tstate);
37978 if (PyErr_Occurred()) SWIG_fail;
37979 }
37980 {
37981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37982 }
37983 return resultobj;
37984 fail:
37985 return NULL;
37986 }
37987
37988
37989 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37990 PyObject *resultobj = 0;
37991 wxWindow *arg1 = (wxWindow *) 0 ;
37992 bool result;
37993 void *argp1 = 0 ;
37994 int res1 = 0 ;
37995 PyObject *swig_obj[1] ;
37996
37997 if (!args) SWIG_fail;
37998 swig_obj[0] = args;
37999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38000 if (!SWIG_IsOK(res1)) {
38001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38002 }
38003 arg1 = reinterpret_cast< wxWindow * >(argp1);
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 result = (bool)(arg1)->LineDown();
38007 wxPyEndAllowThreads(__tstate);
38008 if (PyErr_Occurred()) SWIG_fail;
38009 }
38010 {
38011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38012 }
38013 return resultobj;
38014 fail:
38015 return NULL;
38016 }
38017
38018
38019 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38020 PyObject *resultobj = 0;
38021 wxWindow *arg1 = (wxWindow *) 0 ;
38022 bool result;
38023 void *argp1 = 0 ;
38024 int res1 = 0 ;
38025 PyObject *swig_obj[1] ;
38026
38027 if (!args) SWIG_fail;
38028 swig_obj[0] = args;
38029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38030 if (!SWIG_IsOK(res1)) {
38031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
38032 }
38033 arg1 = reinterpret_cast< wxWindow * >(argp1);
38034 {
38035 PyThreadState* __tstate = wxPyBeginAllowThreads();
38036 result = (bool)(arg1)->PageUp();
38037 wxPyEndAllowThreads(__tstate);
38038 if (PyErr_Occurred()) SWIG_fail;
38039 }
38040 {
38041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38042 }
38043 return resultobj;
38044 fail:
38045 return NULL;
38046 }
38047
38048
38049 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38050 PyObject *resultobj = 0;
38051 wxWindow *arg1 = (wxWindow *) 0 ;
38052 bool result;
38053 void *argp1 = 0 ;
38054 int res1 = 0 ;
38055 PyObject *swig_obj[1] ;
38056
38057 if (!args) SWIG_fail;
38058 swig_obj[0] = args;
38059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
38062 }
38063 arg1 = reinterpret_cast< wxWindow * >(argp1);
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 result = (bool)(arg1)->PageDown();
38067 wxPyEndAllowThreads(__tstate);
38068 if (PyErr_Occurred()) SWIG_fail;
38069 }
38070 {
38071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38072 }
38073 return resultobj;
38074 fail:
38075 return NULL;
38076 }
38077
38078
38079 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38080 PyObject *resultobj = 0;
38081 wxWindow *arg1 = (wxWindow *) 0 ;
38082 wxString *arg2 = 0 ;
38083 void *argp1 = 0 ;
38084 int res1 = 0 ;
38085 bool temp2 = false ;
38086 PyObject * obj0 = 0 ;
38087 PyObject * obj1 = 0 ;
38088 char * kwnames[] = {
38089 (char *) "self",(char *) "text", NULL
38090 };
38091
38092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
38093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38094 if (!SWIG_IsOK(res1)) {
38095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
38096 }
38097 arg1 = reinterpret_cast< wxWindow * >(argp1);
38098 {
38099 arg2 = wxString_in_helper(obj1);
38100 if (arg2 == NULL) SWIG_fail;
38101 temp2 = true;
38102 }
38103 {
38104 PyThreadState* __tstate = wxPyBeginAllowThreads();
38105 (arg1)->SetHelpText((wxString const &)*arg2);
38106 wxPyEndAllowThreads(__tstate);
38107 if (PyErr_Occurred()) SWIG_fail;
38108 }
38109 resultobj = SWIG_Py_Void();
38110 {
38111 if (temp2)
38112 delete arg2;
38113 }
38114 return resultobj;
38115 fail:
38116 {
38117 if (temp2)
38118 delete arg2;
38119 }
38120 return NULL;
38121 }
38122
38123
38124 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38125 PyObject *resultobj = 0;
38126 wxWindow *arg1 = (wxWindow *) 0 ;
38127 wxString *arg2 = 0 ;
38128 void *argp1 = 0 ;
38129 int res1 = 0 ;
38130 bool temp2 = false ;
38131 PyObject * obj0 = 0 ;
38132 PyObject * obj1 = 0 ;
38133 char * kwnames[] = {
38134 (char *) "self",(char *) "text", NULL
38135 };
38136
38137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
38138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38139 if (!SWIG_IsOK(res1)) {
38140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
38141 }
38142 arg1 = reinterpret_cast< wxWindow * >(argp1);
38143 {
38144 arg2 = wxString_in_helper(obj1);
38145 if (arg2 == NULL) SWIG_fail;
38146 temp2 = true;
38147 }
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 (arg1)->SetHelpTextForId((wxString const &)*arg2);
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_Py_Void();
38155 {
38156 if (temp2)
38157 delete arg2;
38158 }
38159 return resultobj;
38160 fail:
38161 {
38162 if (temp2)
38163 delete arg2;
38164 }
38165 return NULL;
38166 }
38167
38168
38169 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38170 PyObject *resultobj = 0;
38171 wxWindow *arg1 = (wxWindow *) 0 ;
38172 wxPoint *arg2 = 0 ;
38173 wxHelpEvent::Origin arg3 ;
38174 wxString result;
38175 void *argp1 = 0 ;
38176 int res1 = 0 ;
38177 wxPoint temp2 ;
38178 void *argp3 ;
38179 int res3 = 0 ;
38180 PyObject * obj0 = 0 ;
38181 PyObject * obj1 = 0 ;
38182 PyObject * obj2 = 0 ;
38183 char * kwnames[] = {
38184 (char *) "self",(char *) "pt",(char *) "origin", NULL
38185 };
38186
38187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38189 if (!SWIG_IsOK(res1)) {
38190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38191 }
38192 arg1 = reinterpret_cast< wxWindow * >(argp1);
38193 {
38194 arg2 = &temp2;
38195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38196 }
38197 {
38198 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
38199 if (!SWIG_IsOK(res3)) {
38200 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38201 }
38202 if (!argp3) {
38203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
38204 } else {
38205 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
38206 arg3 = *temp;
38207 if (SWIG_IsNewObj(res3)) delete temp;
38208 }
38209 }
38210 {
38211 PyThreadState* __tstate = wxPyBeginAllowThreads();
38212 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
38213 wxPyEndAllowThreads(__tstate);
38214 if (PyErr_Occurred()) SWIG_fail;
38215 }
38216 {
38217 #if wxUSE_UNICODE
38218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38219 #else
38220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38221 #endif
38222 }
38223 return resultobj;
38224 fail:
38225 return NULL;
38226 }
38227
38228
38229 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38230 PyObject *resultobj = 0;
38231 wxWindow *arg1 = (wxWindow *) 0 ;
38232 wxString result;
38233 void *argp1 = 0 ;
38234 int res1 = 0 ;
38235 PyObject *swig_obj[1] ;
38236
38237 if (!args) SWIG_fail;
38238 swig_obj[0] = args;
38239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38240 if (!SWIG_IsOK(res1)) {
38241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
38242 }
38243 arg1 = reinterpret_cast< wxWindow * >(argp1);
38244 {
38245 PyThreadState* __tstate = wxPyBeginAllowThreads();
38246 result = ((wxWindow const *)arg1)->GetHelpText();
38247 wxPyEndAllowThreads(__tstate);
38248 if (PyErr_Occurred()) SWIG_fail;
38249 }
38250 {
38251 #if wxUSE_UNICODE
38252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38253 #else
38254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38255 #endif
38256 }
38257 return resultobj;
38258 fail:
38259 return NULL;
38260 }
38261
38262
38263 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38264 PyObject *resultobj = 0;
38265 wxWindow *arg1 = (wxWindow *) 0 ;
38266 wxString *arg2 = 0 ;
38267 void *argp1 = 0 ;
38268 int res1 = 0 ;
38269 bool temp2 = false ;
38270 PyObject * obj0 = 0 ;
38271 PyObject * obj1 = 0 ;
38272 char * kwnames[] = {
38273 (char *) "self",(char *) "tip", NULL
38274 };
38275
38276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
38277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38278 if (!SWIG_IsOK(res1)) {
38279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
38280 }
38281 arg1 = reinterpret_cast< wxWindow * >(argp1);
38282 {
38283 arg2 = wxString_in_helper(obj1);
38284 if (arg2 == NULL) SWIG_fail;
38285 temp2 = true;
38286 }
38287 {
38288 PyThreadState* __tstate = wxPyBeginAllowThreads();
38289 (arg1)->SetToolTip((wxString const &)*arg2);
38290 wxPyEndAllowThreads(__tstate);
38291 if (PyErr_Occurred()) SWIG_fail;
38292 }
38293 resultobj = SWIG_Py_Void();
38294 {
38295 if (temp2)
38296 delete arg2;
38297 }
38298 return resultobj;
38299 fail:
38300 {
38301 if (temp2)
38302 delete arg2;
38303 }
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxWindow *arg1 = (wxWindow *) 0 ;
38311 wxToolTip *arg2 = (wxToolTip *) 0 ;
38312 void *argp1 = 0 ;
38313 int res1 = 0 ;
38314 int res2 = 0 ;
38315 PyObject * obj0 = 0 ;
38316 PyObject * obj1 = 0 ;
38317 char * kwnames[] = {
38318 (char *) "self",(char *) "tip", NULL
38319 };
38320
38321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
38322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
38325 }
38326 arg1 = reinterpret_cast< wxWindow * >(argp1);
38327 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
38328 if (!SWIG_IsOK(res2)) {
38329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
38330 }
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 (arg1)->SetToolTip(arg2);
38334 wxPyEndAllowThreads(__tstate);
38335 if (PyErr_Occurred()) SWIG_fail;
38336 }
38337 resultobj = SWIG_Py_Void();
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38345 PyObject *resultobj = 0;
38346 wxWindow *arg1 = (wxWindow *) 0 ;
38347 wxToolTip *result = 0 ;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
38357 }
38358 arg1 = reinterpret_cast< wxWindow * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
38362 wxPyEndAllowThreads(__tstate);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 }
38365 {
38366 resultobj = wxPyMake_wxObject(result, (bool)0);
38367 }
38368 return resultobj;
38369 fail:
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxWindow *arg1 = (wxWindow *) 0 ;
38377 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
38378 void *argp1 = 0 ;
38379 int res1 = 0 ;
38380 int res2 = 0 ;
38381 PyObject * obj0 = 0 ;
38382 PyObject * obj1 = 0 ;
38383 char * kwnames[] = {
38384 (char *) "self",(char *) "dropTarget", NULL
38385 };
38386
38387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
38388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38389 if (!SWIG_IsOK(res1)) {
38390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
38391 }
38392 arg1 = reinterpret_cast< wxWindow * >(argp1);
38393 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
38394 if (!SWIG_IsOK(res2)) {
38395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
38396 }
38397 {
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 (arg1)->SetDropTarget(arg2);
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 resultobj = SWIG_Py_Void();
38404 return resultobj;
38405 fail:
38406 return NULL;
38407 }
38408
38409
38410 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38411 PyObject *resultobj = 0;
38412 wxWindow *arg1 = (wxWindow *) 0 ;
38413 wxPyDropTarget *result = 0 ;
38414 void *argp1 = 0 ;
38415 int res1 = 0 ;
38416 PyObject *swig_obj[1] ;
38417
38418 if (!args) SWIG_fail;
38419 swig_obj[0] = args;
38420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38421 if (!SWIG_IsOK(res1)) {
38422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
38423 }
38424 arg1 = reinterpret_cast< wxWindow * >(argp1);
38425 {
38426 PyThreadState* __tstate = wxPyBeginAllowThreads();
38427 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
38428 wxPyEndAllowThreads(__tstate);
38429 if (PyErr_Occurred()) SWIG_fail;
38430 }
38431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
38432 return resultobj;
38433 fail:
38434 return NULL;
38435 }
38436
38437
38438 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38439 PyObject *resultobj = 0;
38440 wxWindow *arg1 = (wxWindow *) 0 ;
38441 bool arg2 ;
38442 void *argp1 = 0 ;
38443 int res1 = 0 ;
38444 bool val2 ;
38445 int ecode2 = 0 ;
38446 PyObject * obj0 = 0 ;
38447 PyObject * obj1 = 0 ;
38448 char * kwnames[] = {
38449 (char *) "self",(char *) "accept", NULL
38450 };
38451
38452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
38453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38454 if (!SWIG_IsOK(res1)) {
38455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
38456 }
38457 arg1 = reinterpret_cast< wxWindow * >(argp1);
38458 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38459 if (!SWIG_IsOK(ecode2)) {
38460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
38461 }
38462 arg2 = static_cast< bool >(val2);
38463 {
38464 PyThreadState* __tstate = wxPyBeginAllowThreads();
38465 wxWindow_DragAcceptFiles(arg1,arg2);
38466 wxPyEndAllowThreads(__tstate);
38467 if (PyErr_Occurred()) SWIG_fail;
38468 }
38469 resultobj = SWIG_Py_Void();
38470 return resultobj;
38471 fail:
38472 return NULL;
38473 }
38474
38475
38476 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38477 PyObject *resultobj = 0;
38478 wxWindow *arg1 = (wxWindow *) 0 ;
38479 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
38480 void *argp1 = 0 ;
38481 int res1 = 0 ;
38482 int res2 = 0 ;
38483 PyObject * obj0 = 0 ;
38484 PyObject * obj1 = 0 ;
38485 char * kwnames[] = {
38486 (char *) "self",(char *) "constraints", NULL
38487 };
38488
38489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38491 if (!SWIG_IsOK(res1)) {
38492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38493 }
38494 arg1 = reinterpret_cast< wxWindow * >(argp1);
38495 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38496 if (!SWIG_IsOK(res2)) {
38497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38498 }
38499 {
38500 PyThreadState* __tstate = wxPyBeginAllowThreads();
38501 (arg1)->SetConstraints(arg2);
38502 wxPyEndAllowThreads(__tstate);
38503 if (PyErr_Occurred()) SWIG_fail;
38504 }
38505 resultobj = SWIG_Py_Void();
38506 return resultobj;
38507 fail:
38508 return NULL;
38509 }
38510
38511
38512 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38513 PyObject *resultobj = 0;
38514 wxWindow *arg1 = (wxWindow *) 0 ;
38515 wxLayoutConstraints *result = 0 ;
38516 void *argp1 = 0 ;
38517 int res1 = 0 ;
38518 PyObject *swig_obj[1] ;
38519
38520 if (!args) SWIG_fail;
38521 swig_obj[0] = args;
38522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38523 if (!SWIG_IsOK(res1)) {
38524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38525 }
38526 arg1 = reinterpret_cast< wxWindow * >(argp1);
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38541 PyObject *resultobj = 0;
38542 wxWindow *arg1 = (wxWindow *) 0 ;
38543 bool arg2 ;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 bool val2 ;
38547 int ecode2 = 0 ;
38548 PyObject * obj0 = 0 ;
38549 PyObject * obj1 = 0 ;
38550 char * kwnames[] = {
38551 (char *) "self",(char *) "autoLayout", NULL
38552 };
38553
38554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38556 if (!SWIG_IsOK(res1)) {
38557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38558 }
38559 arg1 = reinterpret_cast< wxWindow * >(argp1);
38560 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38561 if (!SWIG_IsOK(ecode2)) {
38562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38563 }
38564 arg2 = static_cast< bool >(val2);
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->SetAutoLayout(arg2);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 resultobj = SWIG_Py_Void();
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38579 PyObject *resultobj = 0;
38580 wxWindow *arg1 = (wxWindow *) 0 ;
38581 bool result;
38582 void *argp1 = 0 ;
38583 int res1 = 0 ;
38584 PyObject *swig_obj[1] ;
38585
38586 if (!args) SWIG_fail;
38587 swig_obj[0] = args;
38588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38589 if (!SWIG_IsOK(res1)) {
38590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38591 }
38592 arg1 = reinterpret_cast< wxWindow * >(argp1);
38593 {
38594 PyThreadState* __tstate = wxPyBeginAllowThreads();
38595 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38596 wxPyEndAllowThreads(__tstate);
38597 if (PyErr_Occurred()) SWIG_fail;
38598 }
38599 {
38600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38601 }
38602 return resultobj;
38603 fail:
38604 return NULL;
38605 }
38606
38607
38608 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38609 PyObject *resultobj = 0;
38610 wxWindow *arg1 = (wxWindow *) 0 ;
38611 bool result;
38612 void *argp1 = 0 ;
38613 int res1 = 0 ;
38614 PyObject *swig_obj[1] ;
38615
38616 if (!args) SWIG_fail;
38617 swig_obj[0] = args;
38618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38619 if (!SWIG_IsOK(res1)) {
38620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38621 }
38622 arg1 = reinterpret_cast< wxWindow * >(argp1);
38623 {
38624 PyThreadState* __tstate = wxPyBeginAllowThreads();
38625 result = (bool)(arg1)->Layout();
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38631 }
38632 return resultobj;
38633 fail:
38634 return NULL;
38635 }
38636
38637
38638 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38639 PyObject *resultobj = 0;
38640 wxWindow *arg1 = (wxWindow *) 0 ;
38641 wxSizer *arg2 = (wxSizer *) 0 ;
38642 bool arg3 = (bool) true ;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 int res2 = 0 ;
38646 bool val3 ;
38647 int ecode3 = 0 ;
38648 PyObject * obj0 = 0 ;
38649 PyObject * obj1 = 0 ;
38650 PyObject * obj2 = 0 ;
38651 char * kwnames[] = {
38652 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38653 };
38654
38655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38657 if (!SWIG_IsOK(res1)) {
38658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38659 }
38660 arg1 = reinterpret_cast< wxWindow * >(argp1);
38661 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38662 if (!SWIG_IsOK(res2)) {
38663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38664 }
38665 if (obj2) {
38666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38667 if (!SWIG_IsOK(ecode3)) {
38668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38669 }
38670 arg3 = static_cast< bool >(val3);
38671 }
38672 {
38673 PyThreadState* __tstate = wxPyBeginAllowThreads();
38674 (arg1)->SetSizer(arg2,arg3);
38675 wxPyEndAllowThreads(__tstate);
38676 if (PyErr_Occurred()) SWIG_fail;
38677 }
38678 resultobj = SWIG_Py_Void();
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj = 0;
38687 wxWindow *arg1 = (wxWindow *) 0 ;
38688 wxSizer *arg2 = (wxSizer *) 0 ;
38689 bool arg3 = (bool) true ;
38690 void *argp1 = 0 ;
38691 int res1 = 0 ;
38692 int res2 = 0 ;
38693 bool val3 ;
38694 int ecode3 = 0 ;
38695 PyObject * obj0 = 0 ;
38696 PyObject * obj1 = 0 ;
38697 PyObject * obj2 = 0 ;
38698 char * kwnames[] = {
38699 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38700 };
38701
38702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38704 if (!SWIG_IsOK(res1)) {
38705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38706 }
38707 arg1 = reinterpret_cast< wxWindow * >(argp1);
38708 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38709 if (!SWIG_IsOK(res2)) {
38710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38711 }
38712 if (obj2) {
38713 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38714 if (!SWIG_IsOK(ecode3)) {
38715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38716 }
38717 arg3 = static_cast< bool >(val3);
38718 }
38719 {
38720 PyThreadState* __tstate = wxPyBeginAllowThreads();
38721 (arg1)->SetSizerAndFit(arg2,arg3);
38722 wxPyEndAllowThreads(__tstate);
38723 if (PyErr_Occurred()) SWIG_fail;
38724 }
38725 resultobj = SWIG_Py_Void();
38726 return resultobj;
38727 fail:
38728 return NULL;
38729 }
38730
38731
38732 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38733 PyObject *resultobj = 0;
38734 wxWindow *arg1 = (wxWindow *) 0 ;
38735 wxSizer *result = 0 ;
38736 void *argp1 = 0 ;
38737 int res1 = 0 ;
38738 PyObject *swig_obj[1] ;
38739
38740 if (!args) SWIG_fail;
38741 swig_obj[0] = args;
38742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38743 if (!SWIG_IsOK(res1)) {
38744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38745 }
38746 arg1 = reinterpret_cast< wxWindow * >(argp1);
38747 {
38748 PyThreadState* __tstate = wxPyBeginAllowThreads();
38749 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38750 wxPyEndAllowThreads(__tstate);
38751 if (PyErr_Occurred()) SWIG_fail;
38752 }
38753 {
38754 resultobj = wxPyMake_wxObject(result, (bool)0);
38755 }
38756 return resultobj;
38757 fail:
38758 return NULL;
38759 }
38760
38761
38762 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38763 PyObject *resultobj = 0;
38764 wxWindow *arg1 = (wxWindow *) 0 ;
38765 wxSizer *arg2 = (wxSizer *) 0 ;
38766 void *argp1 = 0 ;
38767 int res1 = 0 ;
38768 void *argp2 = 0 ;
38769 int res2 = 0 ;
38770 PyObject * obj0 = 0 ;
38771 PyObject * obj1 = 0 ;
38772 char * kwnames[] = {
38773 (char *) "self",(char *) "sizer", NULL
38774 };
38775
38776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38778 if (!SWIG_IsOK(res1)) {
38779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38780 }
38781 arg1 = reinterpret_cast< wxWindow * >(argp1);
38782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38783 if (!SWIG_IsOK(res2)) {
38784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38785 }
38786 arg2 = reinterpret_cast< wxSizer * >(argp2);
38787 {
38788 PyThreadState* __tstate = wxPyBeginAllowThreads();
38789 (arg1)->SetContainingSizer(arg2);
38790 wxPyEndAllowThreads(__tstate);
38791 if (PyErr_Occurred()) SWIG_fail;
38792 }
38793 resultobj = SWIG_Py_Void();
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38801 PyObject *resultobj = 0;
38802 wxWindow *arg1 = (wxWindow *) 0 ;
38803 wxSizer *result = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 PyObject *swig_obj[1] ;
38807
38808 if (!args) SWIG_fail;
38809 swig_obj[0] = args;
38810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38811 if (!SWIG_IsOK(res1)) {
38812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38813 }
38814 arg1 = reinterpret_cast< wxWindow * >(argp1);
38815 {
38816 PyThreadState* __tstate = wxPyBeginAllowThreads();
38817 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38818 wxPyEndAllowThreads(__tstate);
38819 if (PyErr_Occurred()) SWIG_fail;
38820 }
38821 {
38822 resultobj = wxPyMake_wxObject(result, (bool)0);
38823 }
38824 return resultobj;
38825 fail:
38826 return NULL;
38827 }
38828
38829
38830 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38831 PyObject *resultobj = 0;
38832 wxWindow *arg1 = (wxWindow *) 0 ;
38833 void *argp1 = 0 ;
38834 int res1 = 0 ;
38835 PyObject *swig_obj[1] ;
38836
38837 if (!args) SWIG_fail;
38838 swig_obj[0] = args;
38839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38840 if (!SWIG_IsOK(res1)) {
38841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38842 }
38843 arg1 = reinterpret_cast< wxWindow * >(argp1);
38844 {
38845 PyThreadState* __tstate = wxPyBeginAllowThreads();
38846 (arg1)->InheritAttributes();
38847 wxPyEndAllowThreads(__tstate);
38848 if (PyErr_Occurred()) SWIG_fail;
38849 }
38850 resultobj = SWIG_Py_Void();
38851 return resultobj;
38852 fail:
38853 return NULL;
38854 }
38855
38856
38857 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38858 PyObject *resultobj = 0;
38859 wxWindow *arg1 = (wxWindow *) 0 ;
38860 bool result;
38861 void *argp1 = 0 ;
38862 int res1 = 0 ;
38863 PyObject *swig_obj[1] ;
38864
38865 if (!args) SWIG_fail;
38866 swig_obj[0] = args;
38867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38868 if (!SWIG_IsOK(res1)) {
38869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38870 }
38871 arg1 = reinterpret_cast< wxWindow * >(argp1);
38872 {
38873 PyThreadState* __tstate = wxPyBeginAllowThreads();
38874 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38875 wxPyEndAllowThreads(__tstate);
38876 if (PyErr_Occurred()) SWIG_fail;
38877 }
38878 {
38879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38880 }
38881 return resultobj;
38882 fail:
38883 return NULL;
38884 }
38885
38886
38887 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38888 PyObject *resultobj = 0;
38889 wxWindow *arg1 = (wxWindow *) 0 ;
38890 bool result;
38891 void *argp1 = 0 ;
38892 int res1 = 0 ;
38893 PyObject *swig_obj[1] ;
38894
38895 if (!args) SWIG_fail;
38896 swig_obj[0] = args;
38897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38898 if (!SWIG_IsOK(res1)) {
38899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38900 }
38901 arg1 = reinterpret_cast< wxWindow * >(argp1);
38902 {
38903 PyThreadState* __tstate = wxPyBeginAllowThreads();
38904 result = (bool)(arg1)->CanSetTransparent();
38905 wxPyEndAllowThreads(__tstate);
38906 if (PyErr_Occurred()) SWIG_fail;
38907 }
38908 {
38909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38910 }
38911 return resultobj;
38912 fail:
38913 return NULL;
38914 }
38915
38916
38917 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38918 PyObject *resultobj = 0;
38919 wxWindow *arg1 = (wxWindow *) 0 ;
38920 byte arg2 ;
38921 bool result;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 unsigned char val2 ;
38925 int ecode2 = 0 ;
38926 PyObject * obj0 = 0 ;
38927 PyObject * obj1 = 0 ;
38928 char * kwnames[] = {
38929 (char *) "self",(char *) "alpha", NULL
38930 };
38931
38932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38934 if (!SWIG_IsOK(res1)) {
38935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38936 }
38937 arg1 = reinterpret_cast< wxWindow * >(argp1);
38938 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38939 if (!SWIG_IsOK(ecode2)) {
38940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38941 }
38942 arg2 = static_cast< byte >(val2);
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 result = (bool)(arg1)->SetTransparent(arg2);
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 {
38950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38951 }
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38959 PyObject *obj;
38960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38961 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38962 return SWIG_Py_Void();
38963 }
38964
38965 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38966 return SWIG_Python_InitShadowInstance(args);
38967 }
38968
38969 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38970 PyObject *resultobj = 0;
38971 long arg1 ;
38972 wxWindow *arg2 = (wxWindow *) NULL ;
38973 wxWindow *result = 0 ;
38974 long val1 ;
38975 int ecode1 = 0 ;
38976 void *argp2 = 0 ;
38977 int res2 = 0 ;
38978 PyObject * obj0 = 0 ;
38979 PyObject * obj1 = 0 ;
38980 char * kwnames[] = {
38981 (char *) "id",(char *) "parent", NULL
38982 };
38983
38984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38985 ecode1 = SWIG_AsVal_long(obj0, &val1);
38986 if (!SWIG_IsOK(ecode1)) {
38987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38988 }
38989 arg1 = static_cast< long >(val1);
38990 if (obj1) {
38991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38992 if (!SWIG_IsOK(res2)) {
38993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38994 }
38995 arg2 = reinterpret_cast< wxWindow * >(argp2);
38996 }
38997 {
38998 if (!wxPyCheckForApp()) SWIG_fail;
38999 PyThreadState* __tstate = wxPyBeginAllowThreads();
39000 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
39001 wxPyEndAllowThreads(__tstate);
39002 if (PyErr_Occurred()) SWIG_fail;
39003 }
39004 {
39005 resultobj = wxPyMake_wxObject(result, 0);
39006 }
39007 return resultobj;
39008 fail:
39009 return NULL;
39010 }
39011
39012
39013 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39014 PyObject *resultobj = 0;
39015 wxString *arg1 = 0 ;
39016 wxWindow *arg2 = (wxWindow *) NULL ;
39017 wxWindow *result = 0 ;
39018 bool temp1 = false ;
39019 void *argp2 = 0 ;
39020 int res2 = 0 ;
39021 PyObject * obj0 = 0 ;
39022 PyObject * obj1 = 0 ;
39023 char * kwnames[] = {
39024 (char *) "name",(char *) "parent", NULL
39025 };
39026
39027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
39028 {
39029 arg1 = wxString_in_helper(obj0);
39030 if (arg1 == NULL) SWIG_fail;
39031 temp1 = true;
39032 }
39033 if (obj1) {
39034 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39035 if (!SWIG_IsOK(res2)) {
39036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
39037 }
39038 arg2 = reinterpret_cast< wxWindow * >(argp2);
39039 }
39040 {
39041 if (!wxPyCheckForApp()) SWIG_fail;
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
39044 wxPyEndAllowThreads(__tstate);
39045 if (PyErr_Occurred()) SWIG_fail;
39046 }
39047 {
39048 resultobj = wxPyMake_wxObject(result, 0);
39049 }
39050 {
39051 if (temp1)
39052 delete arg1;
39053 }
39054 return resultobj;
39055 fail:
39056 {
39057 if (temp1)
39058 delete arg1;
39059 }
39060 return NULL;
39061 }
39062
39063
39064 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39065 PyObject *resultobj = 0;
39066 wxString *arg1 = 0 ;
39067 wxWindow *arg2 = (wxWindow *) NULL ;
39068 wxWindow *result = 0 ;
39069 bool temp1 = false ;
39070 void *argp2 = 0 ;
39071 int res2 = 0 ;
39072 PyObject * obj0 = 0 ;
39073 PyObject * obj1 = 0 ;
39074 char * kwnames[] = {
39075 (char *) "label",(char *) "parent", NULL
39076 };
39077
39078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39079 {
39080 arg1 = wxString_in_helper(obj0);
39081 if (arg1 == NULL) SWIG_fail;
39082 temp1 = true;
39083 }
39084 if (obj1) {
39085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39086 if (!SWIG_IsOK(res2)) {
39087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
39088 }
39089 arg2 = reinterpret_cast< wxWindow * >(argp2);
39090 }
39091 {
39092 if (!wxPyCheckForApp()) SWIG_fail;
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 {
39099 resultobj = wxPyMake_wxObject(result, 0);
39100 }
39101 {
39102 if (temp1)
39103 delete arg1;
39104 }
39105 return resultobj;
39106 fail:
39107 {
39108 if (temp1)
39109 delete arg1;
39110 }
39111 return NULL;
39112 }
39113
39114
39115 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39116 PyObject *resultobj = 0;
39117 wxWindow *arg1 = (wxWindow *) 0 ;
39118 unsigned long arg2 ;
39119 wxWindow *result = 0 ;
39120 void *argp1 = 0 ;
39121 int res1 = 0 ;
39122 unsigned long val2 ;
39123 int ecode2 = 0 ;
39124 PyObject * obj0 = 0 ;
39125 PyObject * obj1 = 0 ;
39126 char * kwnames[] = {
39127 (char *) "parent",(char *) "_hWnd", NULL
39128 };
39129
39130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
39131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39132 if (!SWIG_IsOK(res1)) {
39133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
39134 }
39135 arg1 = reinterpret_cast< wxWindow * >(argp1);
39136 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
39137 if (!SWIG_IsOK(ecode2)) {
39138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
39139 }
39140 arg2 = static_cast< unsigned long >(val2);
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
39144 wxPyEndAllowThreads(__tstate);
39145 if (PyErr_Occurred()) SWIG_fail;
39146 }
39147 {
39148 resultobj = wxPyMake_wxObject(result, 0);
39149 }
39150 return resultobj;
39151 fail:
39152 return NULL;
39153 }
39154
39155
39156 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39157 PyObject *resultobj = 0;
39158 PyObject *result = 0 ;
39159
39160 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
39161 {
39162 PyThreadState* __tstate = wxPyBeginAllowThreads();
39163 result = (PyObject *)GetTopLevelWindows();
39164 wxPyEndAllowThreads(__tstate);
39165 if (PyErr_Occurred()) SWIG_fail;
39166 }
39167 resultobj = result;
39168 return resultobj;
39169 fail:
39170 return NULL;
39171 }
39172
39173
39174 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39175 PyObject *resultobj = 0;
39176 wxValidator *result = 0 ;
39177
39178 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
39179 {
39180 PyThreadState* __tstate = wxPyBeginAllowThreads();
39181 result = (wxValidator *)new wxValidator();
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39193 PyObject *resultobj = 0;
39194 wxValidator *arg1 = (wxValidator *) 0 ;
39195 wxValidator *result = 0 ;
39196 void *argp1 = 0 ;
39197 int res1 = 0 ;
39198 PyObject *swig_obj[1] ;
39199
39200 if (!args) SWIG_fail;
39201 swig_obj[0] = args;
39202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39203 if (!SWIG_IsOK(res1)) {
39204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
39205 }
39206 arg1 = reinterpret_cast< wxValidator * >(argp1);
39207 {
39208 PyThreadState* __tstate = wxPyBeginAllowThreads();
39209 result = (wxValidator *)(arg1)->Clone();
39210 wxPyEndAllowThreads(__tstate);
39211 if (PyErr_Occurred()) SWIG_fail;
39212 }
39213 {
39214 resultobj = wxPyMake_wxObject(result, 0);
39215 }
39216 return resultobj;
39217 fail:
39218 return NULL;
39219 }
39220
39221
39222 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39223 PyObject *resultobj = 0;
39224 wxValidator *arg1 = (wxValidator *) 0 ;
39225 wxWindow *arg2 = (wxWindow *) 0 ;
39226 bool result;
39227 void *argp1 = 0 ;
39228 int res1 = 0 ;
39229 void *argp2 = 0 ;
39230 int res2 = 0 ;
39231 PyObject * obj0 = 0 ;
39232 PyObject * obj1 = 0 ;
39233 char * kwnames[] = {
39234 (char *) "self",(char *) "parent", NULL
39235 };
39236
39237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
39238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39239 if (!SWIG_IsOK(res1)) {
39240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
39241 }
39242 arg1 = reinterpret_cast< wxValidator * >(argp1);
39243 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39244 if (!SWIG_IsOK(res2)) {
39245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
39246 }
39247 arg2 = reinterpret_cast< wxWindow * >(argp2);
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 result = (bool)(arg1)->Validate(arg2);
39251 wxPyEndAllowThreads(__tstate);
39252 if (PyErr_Occurred()) SWIG_fail;
39253 }
39254 {
39255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39256 }
39257 return resultobj;
39258 fail:
39259 return NULL;
39260 }
39261
39262
39263 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39264 PyObject *resultobj = 0;
39265 wxValidator *arg1 = (wxValidator *) 0 ;
39266 bool result;
39267 void *argp1 = 0 ;
39268 int res1 = 0 ;
39269 PyObject *swig_obj[1] ;
39270
39271 if (!args) SWIG_fail;
39272 swig_obj[0] = args;
39273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39274 if (!SWIG_IsOK(res1)) {
39275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39276 }
39277 arg1 = reinterpret_cast< wxValidator * >(argp1);
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 result = (bool)(arg1)->TransferToWindow();
39281 wxPyEndAllowThreads(__tstate);
39282 if (PyErr_Occurred()) SWIG_fail;
39283 }
39284 {
39285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39286 }
39287 return resultobj;
39288 fail:
39289 return NULL;
39290 }
39291
39292
39293 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39294 PyObject *resultobj = 0;
39295 wxValidator *arg1 = (wxValidator *) 0 ;
39296 bool result;
39297 void *argp1 = 0 ;
39298 int res1 = 0 ;
39299 PyObject *swig_obj[1] ;
39300
39301 if (!args) SWIG_fail;
39302 swig_obj[0] = args;
39303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39304 if (!SWIG_IsOK(res1)) {
39305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39306 }
39307 arg1 = reinterpret_cast< wxValidator * >(argp1);
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (bool)(arg1)->TransferFromWindow();
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39316 }
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39324 PyObject *resultobj = 0;
39325 wxValidator *arg1 = (wxValidator *) 0 ;
39326 wxWindow *result = 0 ;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329 PyObject *swig_obj[1] ;
39330
39331 if (!args) SWIG_fail;
39332 swig_obj[0] = args;
39333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39334 if (!SWIG_IsOK(res1)) {
39335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39336 }
39337 arg1 = reinterpret_cast< wxValidator * >(argp1);
39338 {
39339 PyThreadState* __tstate = wxPyBeginAllowThreads();
39340 result = (wxWindow *)(arg1)->GetWindow();
39341 wxPyEndAllowThreads(__tstate);
39342 if (PyErr_Occurred()) SWIG_fail;
39343 }
39344 {
39345 resultobj = wxPyMake_wxObject(result, 0);
39346 }
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj = 0;
39355 wxValidator *arg1 = (wxValidator *) 0 ;
39356 wxWindow *arg2 = (wxWindow *) 0 ;
39357 void *argp1 = 0 ;
39358 int res1 = 0 ;
39359 void *argp2 = 0 ;
39360 int res2 = 0 ;
39361 PyObject * obj0 = 0 ;
39362 PyObject * obj1 = 0 ;
39363 char * kwnames[] = {
39364 (char *) "self",(char *) "window", NULL
39365 };
39366
39367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
39368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
39369 if (!SWIG_IsOK(res1)) {
39370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
39371 }
39372 arg1 = reinterpret_cast< wxValidator * >(argp1);
39373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
39374 if (!SWIG_IsOK(res2)) {
39375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
39376 }
39377 arg2 = reinterpret_cast< wxWindow * >(argp2);
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 (arg1)->SetWindow(arg2);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 resultobj = SWIG_Py_Void();
39385 return resultobj;
39386 fail:
39387 return NULL;
39388 }
39389
39390
39391 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39392 PyObject *resultobj = 0;
39393 bool result;
39394
39395 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
39396 {
39397 PyThreadState* __tstate = wxPyBeginAllowThreads();
39398 result = (bool)wxValidator::IsSilent();
39399 wxPyEndAllowThreads(__tstate);
39400 if (PyErr_Occurred()) SWIG_fail;
39401 }
39402 {
39403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39404 }
39405 return resultobj;
39406 fail:
39407 return NULL;
39408 }
39409
39410
39411 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39412 PyObject *resultobj = 0;
39413 int arg1 = (int) true ;
39414 int val1 ;
39415 int ecode1 = 0 ;
39416 PyObject * obj0 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "doIt", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
39422 if (obj0) {
39423 ecode1 = SWIG_AsVal_int(obj0, &val1);
39424 if (!SWIG_IsOK(ecode1)) {
39425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
39426 }
39427 arg1 = static_cast< int >(val1);
39428 }
39429 {
39430 PyThreadState* __tstate = wxPyBeginAllowThreads();
39431 wxValidator::SetBellOnError(arg1);
39432 wxPyEndAllowThreads(__tstate);
39433 if (PyErr_Occurred()) SWIG_fail;
39434 }
39435 resultobj = SWIG_Py_Void();
39436 return resultobj;
39437 fail:
39438 return NULL;
39439 }
39440
39441
39442 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39443 PyObject *obj;
39444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39445 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
39446 return SWIG_Py_Void();
39447 }
39448
39449 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39450 return SWIG_Python_InitShadowInstance(args);
39451 }
39452
39453 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39454 PyObject *resultobj = 0;
39455 wxPyValidator *result = 0 ;
39456
39457 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
39458 {
39459 PyThreadState* __tstate = wxPyBeginAllowThreads();
39460 result = (wxPyValidator *)new wxPyValidator();
39461 wxPyEndAllowThreads(__tstate);
39462 if (PyErr_Occurred()) SWIG_fail;
39463 }
39464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
39465 return resultobj;
39466 fail:
39467 return NULL;
39468 }
39469
39470
39471 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39472 PyObject *resultobj = 0;
39473 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
39474 PyObject *arg2 = (PyObject *) 0 ;
39475 PyObject *arg3 = (PyObject *) 0 ;
39476 int arg4 = (int) true ;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 int val4 ;
39480 int ecode4 = 0 ;
39481 PyObject * obj0 = 0 ;
39482 PyObject * obj1 = 0 ;
39483 PyObject * obj2 = 0 ;
39484 PyObject * obj3 = 0 ;
39485 char * kwnames[] = {
39486 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
39487 };
39488
39489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39491 if (!SWIG_IsOK(res1)) {
39492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39493 }
39494 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39495 arg2 = obj1;
39496 arg3 = obj2;
39497 if (obj3) {
39498 ecode4 = SWIG_AsVal_int(obj3, &val4);
39499 if (!SWIG_IsOK(ecode4)) {
39500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39501 }
39502 arg4 = static_cast< int >(val4);
39503 }
39504 {
39505 PyThreadState* __tstate = wxPyBeginAllowThreads();
39506 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 resultobj = SWIG_Py_Void();
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39518 PyObject *obj;
39519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39520 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39521 return SWIG_Py_Void();
39522 }
39523
39524 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39525 return SWIG_Python_InitShadowInstance(args);
39526 }
39527
39528 SWIGINTERN int DefaultValidator_set(PyObject *) {
39529 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39530 return 1;
39531 }
39532
39533
39534 SWIGINTERN PyObject *DefaultValidator_get(void) {
39535 PyObject *pyobj = 0;
39536
39537 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39538 return pyobj;
39539 }
39540
39541
39542 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39543 PyObject *resultobj = 0;
39544 wxString const &arg1_defvalue = wxPyEmptyString ;
39545 wxString *arg1 = (wxString *) &arg1_defvalue ;
39546 long arg2 = (long) 0 ;
39547 wxMenu *result = 0 ;
39548 bool temp1 = false ;
39549 long val2 ;
39550 int ecode2 = 0 ;
39551 PyObject * obj0 = 0 ;
39552 PyObject * obj1 = 0 ;
39553 char * kwnames[] = {
39554 (char *) "title",(char *) "style", NULL
39555 };
39556
39557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39558 if (obj0) {
39559 {
39560 arg1 = wxString_in_helper(obj0);
39561 if (arg1 == NULL) SWIG_fail;
39562 temp1 = true;
39563 }
39564 }
39565 if (obj1) {
39566 ecode2 = SWIG_AsVal_long(obj1, &val2);
39567 if (!SWIG_IsOK(ecode2)) {
39568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39569 }
39570 arg2 = static_cast< long >(val2);
39571 }
39572 {
39573 if (!wxPyCheckForApp()) SWIG_fail;
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39576 wxPyEndAllowThreads(__tstate);
39577 if (PyErr_Occurred()) SWIG_fail;
39578 }
39579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39580 {
39581 if (temp1)
39582 delete arg1;
39583 }
39584 return resultobj;
39585 fail:
39586 {
39587 if (temp1)
39588 delete arg1;
39589 }
39590 return NULL;
39591 }
39592
39593
39594 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxMenu *arg1 = (wxMenu *) 0 ;
39597 int arg2 ;
39598 wxString const &arg3_defvalue = wxPyEmptyString ;
39599 wxString *arg3 = (wxString *) &arg3_defvalue ;
39600 wxString const &arg4_defvalue = wxPyEmptyString ;
39601 wxString *arg4 = (wxString *) &arg4_defvalue ;
39602 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39603 wxMenuItem *result = 0 ;
39604 void *argp1 = 0 ;
39605 int res1 = 0 ;
39606 int val2 ;
39607 int ecode2 = 0 ;
39608 bool temp3 = false ;
39609 bool temp4 = false ;
39610 int val5 ;
39611 int ecode5 = 0 ;
39612 PyObject * obj0 = 0 ;
39613 PyObject * obj1 = 0 ;
39614 PyObject * obj2 = 0 ;
39615 PyObject * obj3 = 0 ;
39616 PyObject * obj4 = 0 ;
39617 char * kwnames[] = {
39618 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39619 };
39620
39621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39623 if (!SWIG_IsOK(res1)) {
39624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39625 }
39626 arg1 = reinterpret_cast< wxMenu * >(argp1);
39627 ecode2 = SWIG_AsVal_int(obj1, &val2);
39628 if (!SWIG_IsOK(ecode2)) {
39629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39630 }
39631 arg2 = static_cast< int >(val2);
39632 if (obj2) {
39633 {
39634 arg3 = wxString_in_helper(obj2);
39635 if (arg3 == NULL) SWIG_fail;
39636 temp3 = true;
39637 }
39638 }
39639 if (obj3) {
39640 {
39641 arg4 = wxString_in_helper(obj3);
39642 if (arg4 == NULL) SWIG_fail;
39643 temp4 = true;
39644 }
39645 }
39646 if (obj4) {
39647 ecode5 = SWIG_AsVal_int(obj4, &val5);
39648 if (!SWIG_IsOK(ecode5)) {
39649 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39650 }
39651 arg5 = static_cast< wxItemKind >(val5);
39652 }
39653 {
39654 PyThreadState* __tstate = wxPyBeginAllowThreads();
39655 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39656 wxPyEndAllowThreads(__tstate);
39657 if (PyErr_Occurred()) SWIG_fail;
39658 }
39659 {
39660 resultobj = wxPyMake_wxObject(result, (bool)0);
39661 }
39662 {
39663 if (temp3)
39664 delete arg3;
39665 }
39666 {
39667 if (temp4)
39668 delete arg4;
39669 }
39670 return resultobj;
39671 fail:
39672 {
39673 if (temp3)
39674 delete arg3;
39675 }
39676 {
39677 if (temp4)
39678 delete arg4;
39679 }
39680 return NULL;
39681 }
39682
39683
39684 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39685 PyObject *resultobj = 0;
39686 wxMenu *arg1 = (wxMenu *) 0 ;
39687 wxMenuItem *result = 0 ;
39688 void *argp1 = 0 ;
39689 int res1 = 0 ;
39690 PyObject *swig_obj[1] ;
39691
39692 if (!args) SWIG_fail;
39693 swig_obj[0] = args;
39694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39695 if (!SWIG_IsOK(res1)) {
39696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39697 }
39698 arg1 = reinterpret_cast< wxMenu * >(argp1);
39699 {
39700 PyThreadState* __tstate = wxPyBeginAllowThreads();
39701 result = (wxMenuItem *)(arg1)->AppendSeparator();
39702 wxPyEndAllowThreads(__tstate);
39703 if (PyErr_Occurred()) SWIG_fail;
39704 }
39705 {
39706 resultobj = wxPyMake_wxObject(result, (bool)0);
39707 }
39708 return resultobj;
39709 fail:
39710 return NULL;
39711 }
39712
39713
39714 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39715 PyObject *resultobj = 0;
39716 wxMenu *arg1 = (wxMenu *) 0 ;
39717 int arg2 ;
39718 wxString *arg3 = 0 ;
39719 wxString const &arg4_defvalue = wxPyEmptyString ;
39720 wxString *arg4 = (wxString *) &arg4_defvalue ;
39721 wxMenuItem *result = 0 ;
39722 void *argp1 = 0 ;
39723 int res1 = 0 ;
39724 int val2 ;
39725 int ecode2 = 0 ;
39726 bool temp3 = false ;
39727 bool temp4 = false ;
39728 PyObject * obj0 = 0 ;
39729 PyObject * obj1 = 0 ;
39730 PyObject * obj2 = 0 ;
39731 PyObject * obj3 = 0 ;
39732 char * kwnames[] = {
39733 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39734 };
39735
39736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39738 if (!SWIG_IsOK(res1)) {
39739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39740 }
39741 arg1 = reinterpret_cast< wxMenu * >(argp1);
39742 ecode2 = SWIG_AsVal_int(obj1, &val2);
39743 if (!SWIG_IsOK(ecode2)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39745 }
39746 arg2 = static_cast< int >(val2);
39747 {
39748 arg3 = wxString_in_helper(obj2);
39749 if (arg3 == NULL) SWIG_fail;
39750 temp3 = true;
39751 }
39752 if (obj3) {
39753 {
39754 arg4 = wxString_in_helper(obj3);
39755 if (arg4 == NULL) SWIG_fail;
39756 temp4 = true;
39757 }
39758 }
39759 {
39760 PyThreadState* __tstate = wxPyBeginAllowThreads();
39761 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39762 wxPyEndAllowThreads(__tstate);
39763 if (PyErr_Occurred()) SWIG_fail;
39764 }
39765 {
39766 resultobj = wxPyMake_wxObject(result, (bool)0);
39767 }
39768 {
39769 if (temp3)
39770 delete arg3;
39771 }
39772 {
39773 if (temp4)
39774 delete arg4;
39775 }
39776 return resultobj;
39777 fail:
39778 {
39779 if (temp3)
39780 delete arg3;
39781 }
39782 {
39783 if (temp4)
39784 delete arg4;
39785 }
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 int arg2 ;
39794 wxString *arg3 = 0 ;
39795 wxString const &arg4_defvalue = wxPyEmptyString ;
39796 wxString *arg4 = (wxString *) &arg4_defvalue ;
39797 wxMenuItem *result = 0 ;
39798 void *argp1 = 0 ;
39799 int res1 = 0 ;
39800 int val2 ;
39801 int ecode2 = 0 ;
39802 bool temp3 = false ;
39803 bool temp4 = false ;
39804 PyObject * obj0 = 0 ;
39805 PyObject * obj1 = 0 ;
39806 PyObject * obj2 = 0 ;
39807 PyObject * obj3 = 0 ;
39808 char * kwnames[] = {
39809 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39810 };
39811
39812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39814 if (!SWIG_IsOK(res1)) {
39815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39816 }
39817 arg1 = reinterpret_cast< wxMenu * >(argp1);
39818 ecode2 = SWIG_AsVal_int(obj1, &val2);
39819 if (!SWIG_IsOK(ecode2)) {
39820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39821 }
39822 arg2 = static_cast< int >(val2);
39823 {
39824 arg3 = wxString_in_helper(obj2);
39825 if (arg3 == NULL) SWIG_fail;
39826 temp3 = true;
39827 }
39828 if (obj3) {
39829 {
39830 arg4 = wxString_in_helper(obj3);
39831 if (arg4 == NULL) SWIG_fail;
39832 temp4 = true;
39833 }
39834 }
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 {
39842 resultobj = wxPyMake_wxObject(result, (bool)0);
39843 }
39844 {
39845 if (temp3)
39846 delete arg3;
39847 }
39848 {
39849 if (temp4)
39850 delete arg4;
39851 }
39852 return resultobj;
39853 fail:
39854 {
39855 if (temp3)
39856 delete arg3;
39857 }
39858 {
39859 if (temp4)
39860 delete arg4;
39861 }
39862 return NULL;
39863 }
39864
39865
39866 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39867 PyObject *resultobj = 0;
39868 wxMenu *arg1 = (wxMenu *) 0 ;
39869 int arg2 ;
39870 wxString *arg3 = 0 ;
39871 wxMenu *arg4 = (wxMenu *) 0 ;
39872 wxString const &arg5_defvalue = wxPyEmptyString ;
39873 wxString *arg5 = (wxString *) &arg5_defvalue ;
39874 wxMenuItem *result = 0 ;
39875 void *argp1 = 0 ;
39876 int res1 = 0 ;
39877 int val2 ;
39878 int ecode2 = 0 ;
39879 bool temp3 = false ;
39880 void *argp4 = 0 ;
39881 int res4 = 0 ;
39882 bool temp5 = false ;
39883 PyObject * obj0 = 0 ;
39884 PyObject * obj1 = 0 ;
39885 PyObject * obj2 = 0 ;
39886 PyObject * obj3 = 0 ;
39887 PyObject * obj4 = 0 ;
39888 char * kwnames[] = {
39889 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39890 };
39891
39892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39894 if (!SWIG_IsOK(res1)) {
39895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39896 }
39897 arg1 = reinterpret_cast< wxMenu * >(argp1);
39898 ecode2 = SWIG_AsVal_int(obj1, &val2);
39899 if (!SWIG_IsOK(ecode2)) {
39900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39901 }
39902 arg2 = static_cast< int >(val2);
39903 {
39904 arg3 = wxString_in_helper(obj2);
39905 if (arg3 == NULL) SWIG_fail;
39906 temp3 = true;
39907 }
39908 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39909 if (!SWIG_IsOK(res4)) {
39910 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39911 }
39912 arg4 = reinterpret_cast< wxMenu * >(argp4);
39913 if (obj4) {
39914 {
39915 arg5 = wxString_in_helper(obj4);
39916 if (arg5 == NULL) SWIG_fail;
39917 temp5 = true;
39918 }
39919 }
39920 {
39921 PyThreadState* __tstate = wxPyBeginAllowThreads();
39922 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39923 wxPyEndAllowThreads(__tstate);
39924 if (PyErr_Occurred()) SWIG_fail;
39925 }
39926 {
39927 resultobj = wxPyMake_wxObject(result, (bool)0);
39928 }
39929 {
39930 if (temp3)
39931 delete arg3;
39932 }
39933 {
39934 if (temp5)
39935 delete arg5;
39936 }
39937 return resultobj;
39938 fail:
39939 {
39940 if (temp3)
39941 delete arg3;
39942 }
39943 {
39944 if (temp5)
39945 delete arg5;
39946 }
39947 return NULL;
39948 }
39949
39950
39951 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39952 PyObject *resultobj = 0;
39953 wxMenu *arg1 = (wxMenu *) 0 ;
39954 wxMenu *arg2 = (wxMenu *) 0 ;
39955 wxString *arg3 = 0 ;
39956 wxString const &arg4_defvalue = wxPyEmptyString ;
39957 wxString *arg4 = (wxString *) &arg4_defvalue ;
39958 wxMenuItem *result = 0 ;
39959 void *argp1 = 0 ;
39960 int res1 = 0 ;
39961 void *argp2 = 0 ;
39962 int res2 = 0 ;
39963 bool temp3 = false ;
39964 bool temp4 = false ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 PyObject * obj2 = 0 ;
39968 PyObject * obj3 = 0 ;
39969 char * kwnames[] = {
39970 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39971 };
39972
39973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39975 if (!SWIG_IsOK(res1)) {
39976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39977 }
39978 arg1 = reinterpret_cast< wxMenu * >(argp1);
39979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39980 if (!SWIG_IsOK(res2)) {
39981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39982 }
39983 arg2 = reinterpret_cast< wxMenu * >(argp2);
39984 {
39985 arg3 = wxString_in_helper(obj2);
39986 if (arg3 == NULL) SWIG_fail;
39987 temp3 = true;
39988 }
39989 if (obj3) {
39990 {
39991 arg4 = wxString_in_helper(obj3);
39992 if (arg4 == NULL) SWIG_fail;
39993 temp4 = true;
39994 }
39995 }
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39999 wxPyEndAllowThreads(__tstate);
40000 if (PyErr_Occurred()) SWIG_fail;
40001 }
40002 {
40003 resultobj = wxPyMake_wxObject(result, (bool)0);
40004 }
40005 {
40006 if (temp3)
40007 delete arg3;
40008 }
40009 {
40010 if (temp4)
40011 delete arg4;
40012 }
40013 return resultobj;
40014 fail:
40015 {
40016 if (temp3)
40017 delete arg3;
40018 }
40019 {
40020 if (temp4)
40021 delete arg4;
40022 }
40023 return NULL;
40024 }
40025
40026
40027 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40028 PyObject *resultobj = 0;
40029 wxMenu *arg1 = (wxMenu *) 0 ;
40030 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40031 wxMenuItem *result = 0 ;
40032 void *argp1 = 0 ;
40033 int res1 = 0 ;
40034 int res2 = 0 ;
40035 PyObject * obj0 = 0 ;
40036 PyObject * obj1 = 0 ;
40037 char * kwnames[] = {
40038 (char *) "self",(char *) "item", NULL
40039 };
40040
40041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
40042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40043 if (!SWIG_IsOK(res1)) {
40044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40045 }
40046 arg1 = reinterpret_cast< wxMenu * >(argp1);
40047 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40048 if (!SWIG_IsOK(res2)) {
40049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40050 }
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 result = (wxMenuItem *)(arg1)->Append(arg2);
40054 wxPyEndAllowThreads(__tstate);
40055 if (PyErr_Occurred()) SWIG_fail;
40056 }
40057 {
40058 resultobj = wxPyMake_wxObject(result, (bool)0);
40059 }
40060 return resultobj;
40061 fail:
40062 return NULL;
40063 }
40064
40065
40066 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40067 PyObject *resultobj = 0;
40068 wxMenu *arg1 = (wxMenu *) 0 ;
40069 size_t arg2 ;
40070 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
40071 wxMenuItem *result = 0 ;
40072 void *argp1 = 0 ;
40073 int res1 = 0 ;
40074 size_t val2 ;
40075 int ecode2 = 0 ;
40076 int res3 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 PyObject * obj2 = 0 ;
40080 char * kwnames[] = {
40081 (char *) "self",(char *) "pos",(char *) "item", NULL
40082 };
40083
40084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40086 if (!SWIG_IsOK(res1)) {
40087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40088 }
40089 arg1 = reinterpret_cast< wxMenu * >(argp1);
40090 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40091 if (!SWIG_IsOK(ecode2)) {
40092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
40093 }
40094 arg2 = static_cast< size_t >(val2);
40095 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40096 if (!SWIG_IsOK(res3)) {
40097 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
40098 }
40099 {
40100 PyThreadState* __tstate = wxPyBeginAllowThreads();
40101 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
40102 wxPyEndAllowThreads(__tstate);
40103 if (PyErr_Occurred()) SWIG_fail;
40104 }
40105 {
40106 resultobj = wxPyMake_wxObject(result, (bool)0);
40107 }
40108 return resultobj;
40109 fail:
40110 return NULL;
40111 }
40112
40113
40114 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40115 PyObject *resultobj = 0;
40116 wxMenu *arg1 = (wxMenu *) 0 ;
40117 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40118 wxMenuItem *result = 0 ;
40119 void *argp1 = 0 ;
40120 int res1 = 0 ;
40121 int res2 = 0 ;
40122 PyObject * obj0 = 0 ;
40123 PyObject * obj1 = 0 ;
40124 char * kwnames[] = {
40125 (char *) "self",(char *) "item", NULL
40126 };
40127
40128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
40129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40130 if (!SWIG_IsOK(res1)) {
40131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40132 }
40133 arg1 = reinterpret_cast< wxMenu * >(argp1);
40134 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
40135 if (!SWIG_IsOK(res2)) {
40136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40137 }
40138 {
40139 PyThreadState* __tstate = wxPyBeginAllowThreads();
40140 result = (wxMenuItem *)(arg1)->Prepend(arg2);
40141 wxPyEndAllowThreads(__tstate);
40142 if (PyErr_Occurred()) SWIG_fail;
40143 }
40144 {
40145 resultobj = wxPyMake_wxObject(result, (bool)0);
40146 }
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40154 PyObject *resultobj = 0;
40155 wxMenu *arg1 = (wxMenu *) 0 ;
40156 void *argp1 = 0 ;
40157 int res1 = 0 ;
40158 PyObject *swig_obj[1] ;
40159
40160 if (!args) SWIG_fail;
40161 swig_obj[0] = args;
40162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40163 if (!SWIG_IsOK(res1)) {
40164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
40165 }
40166 arg1 = reinterpret_cast< wxMenu * >(argp1);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 (arg1)->Break();
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_Py_Void();
40174 return resultobj;
40175 fail:
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40181 PyObject *resultobj = 0;
40182 wxMenu *arg1 = (wxMenu *) 0 ;
40183 size_t arg2 ;
40184 int arg3 ;
40185 wxString const &arg4_defvalue = wxPyEmptyString ;
40186 wxString *arg4 = (wxString *) &arg4_defvalue ;
40187 wxString const &arg5_defvalue = wxPyEmptyString ;
40188 wxString *arg5 = (wxString *) &arg5_defvalue ;
40189 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
40190 wxMenuItem *result = 0 ;
40191 void *argp1 = 0 ;
40192 int res1 = 0 ;
40193 size_t val2 ;
40194 int ecode2 = 0 ;
40195 int val3 ;
40196 int ecode3 = 0 ;
40197 bool temp4 = false ;
40198 bool temp5 = false ;
40199 int val6 ;
40200 int ecode6 = 0 ;
40201 PyObject * obj0 = 0 ;
40202 PyObject * obj1 = 0 ;
40203 PyObject * obj2 = 0 ;
40204 PyObject * obj3 = 0 ;
40205 PyObject * obj4 = 0 ;
40206 PyObject * obj5 = 0 ;
40207 char * kwnames[] = {
40208 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40209 };
40210
40211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40213 if (!SWIG_IsOK(res1)) {
40214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
40215 }
40216 arg1 = reinterpret_cast< wxMenu * >(argp1);
40217 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40218 if (!SWIG_IsOK(ecode2)) {
40219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
40220 }
40221 arg2 = static_cast< size_t >(val2);
40222 ecode3 = SWIG_AsVal_int(obj2, &val3);
40223 if (!SWIG_IsOK(ecode3)) {
40224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
40225 }
40226 arg3 = static_cast< int >(val3);
40227 if (obj3) {
40228 {
40229 arg4 = wxString_in_helper(obj3);
40230 if (arg4 == NULL) SWIG_fail;
40231 temp4 = true;
40232 }
40233 }
40234 if (obj4) {
40235 {
40236 arg5 = wxString_in_helper(obj4);
40237 if (arg5 == NULL) SWIG_fail;
40238 temp5 = true;
40239 }
40240 }
40241 if (obj5) {
40242 ecode6 = SWIG_AsVal_int(obj5, &val6);
40243 if (!SWIG_IsOK(ecode6)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
40245 }
40246 arg6 = static_cast< wxItemKind >(val6);
40247 }
40248 {
40249 PyThreadState* __tstate = wxPyBeginAllowThreads();
40250 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
40251 wxPyEndAllowThreads(__tstate);
40252 if (PyErr_Occurred()) SWIG_fail;
40253 }
40254 {
40255 resultobj = wxPyMake_wxObject(result, (bool)0);
40256 }
40257 {
40258 if (temp4)
40259 delete arg4;
40260 }
40261 {
40262 if (temp5)
40263 delete arg5;
40264 }
40265 return resultobj;
40266 fail:
40267 {
40268 if (temp4)
40269 delete arg4;
40270 }
40271 {
40272 if (temp5)
40273 delete arg5;
40274 }
40275 return NULL;
40276 }
40277
40278
40279 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj = 0;
40281 wxMenu *arg1 = (wxMenu *) 0 ;
40282 size_t arg2 ;
40283 wxMenuItem *result = 0 ;
40284 void *argp1 = 0 ;
40285 int res1 = 0 ;
40286 size_t val2 ;
40287 int ecode2 = 0 ;
40288 PyObject * obj0 = 0 ;
40289 PyObject * obj1 = 0 ;
40290 char * kwnames[] = {
40291 (char *) "self",(char *) "pos", NULL
40292 };
40293
40294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
40295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40296 if (!SWIG_IsOK(res1)) {
40297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40298 }
40299 arg1 = reinterpret_cast< wxMenu * >(argp1);
40300 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40301 if (!SWIG_IsOK(ecode2)) {
40302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
40303 }
40304 arg2 = static_cast< size_t >(val2);
40305 {
40306 PyThreadState* __tstate = wxPyBeginAllowThreads();
40307 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 {
40312 resultobj = wxPyMake_wxObject(result, (bool)0);
40313 }
40314 return resultobj;
40315 fail:
40316 return NULL;
40317 }
40318
40319
40320 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = 0;
40322 wxMenu *arg1 = (wxMenu *) 0 ;
40323 size_t arg2 ;
40324 int arg3 ;
40325 wxString *arg4 = 0 ;
40326 wxString const &arg5_defvalue = wxPyEmptyString ;
40327 wxString *arg5 = (wxString *) &arg5_defvalue ;
40328 wxMenuItem *result = 0 ;
40329 void *argp1 = 0 ;
40330 int res1 = 0 ;
40331 size_t val2 ;
40332 int ecode2 = 0 ;
40333 int val3 ;
40334 int ecode3 = 0 ;
40335 bool temp4 = false ;
40336 bool temp5 = false ;
40337 PyObject * obj0 = 0 ;
40338 PyObject * obj1 = 0 ;
40339 PyObject * obj2 = 0 ;
40340 PyObject * obj3 = 0 ;
40341 PyObject * obj4 = 0 ;
40342 char * kwnames[] = {
40343 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40344 };
40345
40346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40348 if (!SWIG_IsOK(res1)) {
40349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40350 }
40351 arg1 = reinterpret_cast< wxMenu * >(argp1);
40352 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40353 if (!SWIG_IsOK(ecode2)) {
40354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
40355 }
40356 arg2 = static_cast< size_t >(val2);
40357 ecode3 = SWIG_AsVal_int(obj2, &val3);
40358 if (!SWIG_IsOK(ecode3)) {
40359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
40360 }
40361 arg3 = static_cast< int >(val3);
40362 {
40363 arg4 = wxString_in_helper(obj3);
40364 if (arg4 == NULL) SWIG_fail;
40365 temp4 = true;
40366 }
40367 if (obj4) {
40368 {
40369 arg5 = wxString_in_helper(obj4);
40370 if (arg5 == NULL) SWIG_fail;
40371 temp5 = true;
40372 }
40373 }
40374 {
40375 PyThreadState* __tstate = wxPyBeginAllowThreads();
40376 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40377 wxPyEndAllowThreads(__tstate);
40378 if (PyErr_Occurred()) SWIG_fail;
40379 }
40380 {
40381 resultobj = wxPyMake_wxObject(result, (bool)0);
40382 }
40383 {
40384 if (temp4)
40385 delete arg4;
40386 }
40387 {
40388 if (temp5)
40389 delete arg5;
40390 }
40391 return resultobj;
40392 fail:
40393 {
40394 if (temp4)
40395 delete arg4;
40396 }
40397 {
40398 if (temp5)
40399 delete arg5;
40400 }
40401 return NULL;
40402 }
40403
40404
40405 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj = 0;
40407 wxMenu *arg1 = (wxMenu *) 0 ;
40408 size_t arg2 ;
40409 int arg3 ;
40410 wxString *arg4 = 0 ;
40411 wxString const &arg5_defvalue = wxPyEmptyString ;
40412 wxString *arg5 = (wxString *) &arg5_defvalue ;
40413 wxMenuItem *result = 0 ;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 size_t val2 ;
40417 int ecode2 = 0 ;
40418 int val3 ;
40419 int ecode3 = 0 ;
40420 bool temp4 = false ;
40421 bool temp5 = false ;
40422 PyObject * obj0 = 0 ;
40423 PyObject * obj1 = 0 ;
40424 PyObject * obj2 = 0 ;
40425 PyObject * obj3 = 0 ;
40426 PyObject * obj4 = 0 ;
40427 char * kwnames[] = {
40428 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
40429 };
40430
40431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40433 if (!SWIG_IsOK(res1)) {
40434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40435 }
40436 arg1 = reinterpret_cast< wxMenu * >(argp1);
40437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40438 if (!SWIG_IsOK(ecode2)) {
40439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
40440 }
40441 arg2 = static_cast< size_t >(val2);
40442 ecode3 = SWIG_AsVal_int(obj2, &val3);
40443 if (!SWIG_IsOK(ecode3)) {
40444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
40445 }
40446 arg3 = static_cast< int >(val3);
40447 {
40448 arg4 = wxString_in_helper(obj3);
40449 if (arg4 == NULL) SWIG_fail;
40450 temp4 = true;
40451 }
40452 if (obj4) {
40453 {
40454 arg5 = wxString_in_helper(obj4);
40455 if (arg5 == NULL) SWIG_fail;
40456 temp5 = true;
40457 }
40458 }
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
40462 wxPyEndAllowThreads(__tstate);
40463 if (PyErr_Occurred()) SWIG_fail;
40464 }
40465 {
40466 resultobj = wxPyMake_wxObject(result, (bool)0);
40467 }
40468 {
40469 if (temp4)
40470 delete arg4;
40471 }
40472 {
40473 if (temp5)
40474 delete arg5;
40475 }
40476 return resultobj;
40477 fail:
40478 {
40479 if (temp4)
40480 delete arg4;
40481 }
40482 {
40483 if (temp5)
40484 delete arg5;
40485 }
40486 return NULL;
40487 }
40488
40489
40490 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40491 PyObject *resultobj = 0;
40492 wxMenu *arg1 = (wxMenu *) 0 ;
40493 size_t arg2 ;
40494 int arg3 ;
40495 wxString *arg4 = 0 ;
40496 wxMenu *arg5 = (wxMenu *) 0 ;
40497 wxString const &arg6_defvalue = wxPyEmptyString ;
40498 wxString *arg6 = (wxString *) &arg6_defvalue ;
40499 wxMenuItem *result = 0 ;
40500 void *argp1 = 0 ;
40501 int res1 = 0 ;
40502 size_t val2 ;
40503 int ecode2 = 0 ;
40504 int val3 ;
40505 int ecode3 = 0 ;
40506 bool temp4 = false ;
40507 void *argp5 = 0 ;
40508 int res5 = 0 ;
40509 bool temp6 = false ;
40510 PyObject * obj0 = 0 ;
40511 PyObject * obj1 = 0 ;
40512 PyObject * obj2 = 0 ;
40513 PyObject * obj3 = 0 ;
40514 PyObject * obj4 = 0 ;
40515 PyObject * obj5 = 0 ;
40516 char * kwnames[] = {
40517 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40518 };
40519
40520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40522 if (!SWIG_IsOK(res1)) {
40523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40524 }
40525 arg1 = reinterpret_cast< wxMenu * >(argp1);
40526 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40527 if (!SWIG_IsOK(ecode2)) {
40528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40529 }
40530 arg2 = static_cast< size_t >(val2);
40531 ecode3 = SWIG_AsVal_int(obj2, &val3);
40532 if (!SWIG_IsOK(ecode3)) {
40533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40534 }
40535 arg3 = static_cast< int >(val3);
40536 {
40537 arg4 = wxString_in_helper(obj3);
40538 if (arg4 == NULL) SWIG_fail;
40539 temp4 = true;
40540 }
40541 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res5)) {
40543 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40544 }
40545 arg5 = reinterpret_cast< wxMenu * >(argp5);
40546 if (obj5) {
40547 {
40548 arg6 = wxString_in_helper(obj5);
40549 if (arg6 == NULL) SWIG_fail;
40550 temp6 = true;
40551 }
40552 }
40553 {
40554 PyThreadState* __tstate = wxPyBeginAllowThreads();
40555 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40556 wxPyEndAllowThreads(__tstate);
40557 if (PyErr_Occurred()) SWIG_fail;
40558 }
40559 {
40560 resultobj = wxPyMake_wxObject(result, (bool)0);
40561 }
40562 {
40563 if (temp4)
40564 delete arg4;
40565 }
40566 {
40567 if (temp6)
40568 delete arg6;
40569 }
40570 return resultobj;
40571 fail:
40572 {
40573 if (temp4)
40574 delete arg4;
40575 }
40576 {
40577 if (temp6)
40578 delete arg6;
40579 }
40580 return NULL;
40581 }
40582
40583
40584 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj = 0;
40586 wxMenu *arg1 = (wxMenu *) 0 ;
40587 int arg2 ;
40588 wxString const &arg3_defvalue = wxPyEmptyString ;
40589 wxString *arg3 = (wxString *) &arg3_defvalue ;
40590 wxString const &arg4_defvalue = wxPyEmptyString ;
40591 wxString *arg4 = (wxString *) &arg4_defvalue ;
40592 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40593 wxMenuItem *result = 0 ;
40594 void *argp1 = 0 ;
40595 int res1 = 0 ;
40596 int val2 ;
40597 int ecode2 = 0 ;
40598 bool temp3 = false ;
40599 bool temp4 = false ;
40600 int val5 ;
40601 int ecode5 = 0 ;
40602 PyObject * obj0 = 0 ;
40603 PyObject * obj1 = 0 ;
40604 PyObject * obj2 = 0 ;
40605 PyObject * obj3 = 0 ;
40606 PyObject * obj4 = 0 ;
40607 char * kwnames[] = {
40608 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40609 };
40610
40611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40613 if (!SWIG_IsOK(res1)) {
40614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40615 }
40616 arg1 = reinterpret_cast< wxMenu * >(argp1);
40617 ecode2 = SWIG_AsVal_int(obj1, &val2);
40618 if (!SWIG_IsOK(ecode2)) {
40619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40620 }
40621 arg2 = static_cast< int >(val2);
40622 if (obj2) {
40623 {
40624 arg3 = wxString_in_helper(obj2);
40625 if (arg3 == NULL) SWIG_fail;
40626 temp3 = true;
40627 }
40628 }
40629 if (obj3) {
40630 {
40631 arg4 = wxString_in_helper(obj3);
40632 if (arg4 == NULL) SWIG_fail;
40633 temp4 = true;
40634 }
40635 }
40636 if (obj4) {
40637 ecode5 = SWIG_AsVal_int(obj4, &val5);
40638 if (!SWIG_IsOK(ecode5)) {
40639 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40640 }
40641 arg5 = static_cast< wxItemKind >(val5);
40642 }
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40646 wxPyEndAllowThreads(__tstate);
40647 if (PyErr_Occurred()) SWIG_fail;
40648 }
40649 {
40650 resultobj = wxPyMake_wxObject(result, (bool)0);
40651 }
40652 {
40653 if (temp3)
40654 delete arg3;
40655 }
40656 {
40657 if (temp4)
40658 delete arg4;
40659 }
40660 return resultobj;
40661 fail:
40662 {
40663 if (temp3)
40664 delete arg3;
40665 }
40666 {
40667 if (temp4)
40668 delete arg4;
40669 }
40670 return NULL;
40671 }
40672
40673
40674 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40675 PyObject *resultobj = 0;
40676 wxMenu *arg1 = (wxMenu *) 0 ;
40677 wxMenuItem *result = 0 ;
40678 void *argp1 = 0 ;
40679 int res1 = 0 ;
40680 PyObject *swig_obj[1] ;
40681
40682 if (!args) SWIG_fail;
40683 swig_obj[0] = args;
40684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40687 }
40688 arg1 = reinterpret_cast< wxMenu * >(argp1);
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 result = (wxMenuItem *)(arg1)->PrependSeparator();
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 {
40696 resultobj = wxPyMake_wxObject(result, (bool)0);
40697 }
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40705 PyObject *resultobj = 0;
40706 wxMenu *arg1 = (wxMenu *) 0 ;
40707 int arg2 ;
40708 wxString *arg3 = 0 ;
40709 wxString const &arg4_defvalue = wxPyEmptyString ;
40710 wxString *arg4 = (wxString *) &arg4_defvalue ;
40711 wxMenuItem *result = 0 ;
40712 void *argp1 = 0 ;
40713 int res1 = 0 ;
40714 int val2 ;
40715 int ecode2 = 0 ;
40716 bool temp3 = false ;
40717 bool temp4 = false ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 PyObject * obj2 = 0 ;
40721 PyObject * obj3 = 0 ;
40722 char * kwnames[] = {
40723 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40724 };
40725
40726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40728 if (!SWIG_IsOK(res1)) {
40729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40730 }
40731 arg1 = reinterpret_cast< wxMenu * >(argp1);
40732 ecode2 = SWIG_AsVal_int(obj1, &val2);
40733 if (!SWIG_IsOK(ecode2)) {
40734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40735 }
40736 arg2 = static_cast< int >(val2);
40737 {
40738 arg3 = wxString_in_helper(obj2);
40739 if (arg3 == NULL) SWIG_fail;
40740 temp3 = true;
40741 }
40742 if (obj3) {
40743 {
40744 arg4 = wxString_in_helper(obj3);
40745 if (arg4 == NULL) SWIG_fail;
40746 temp4 = true;
40747 }
40748 }
40749 {
40750 PyThreadState* __tstate = wxPyBeginAllowThreads();
40751 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40752 wxPyEndAllowThreads(__tstate);
40753 if (PyErr_Occurred()) SWIG_fail;
40754 }
40755 {
40756 resultobj = wxPyMake_wxObject(result, (bool)0);
40757 }
40758 {
40759 if (temp3)
40760 delete arg3;
40761 }
40762 {
40763 if (temp4)
40764 delete arg4;
40765 }
40766 return resultobj;
40767 fail:
40768 {
40769 if (temp3)
40770 delete arg3;
40771 }
40772 {
40773 if (temp4)
40774 delete arg4;
40775 }
40776 return NULL;
40777 }
40778
40779
40780 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj = 0;
40782 wxMenu *arg1 = (wxMenu *) 0 ;
40783 int arg2 ;
40784 wxString *arg3 = 0 ;
40785 wxString const &arg4_defvalue = wxPyEmptyString ;
40786 wxString *arg4 = (wxString *) &arg4_defvalue ;
40787 wxMenuItem *result = 0 ;
40788 void *argp1 = 0 ;
40789 int res1 = 0 ;
40790 int val2 ;
40791 int ecode2 = 0 ;
40792 bool temp3 = false ;
40793 bool temp4 = false ;
40794 PyObject * obj0 = 0 ;
40795 PyObject * obj1 = 0 ;
40796 PyObject * obj2 = 0 ;
40797 PyObject * obj3 = 0 ;
40798 char * kwnames[] = {
40799 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40800 };
40801
40802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40804 if (!SWIG_IsOK(res1)) {
40805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40806 }
40807 arg1 = reinterpret_cast< wxMenu * >(argp1);
40808 ecode2 = SWIG_AsVal_int(obj1, &val2);
40809 if (!SWIG_IsOK(ecode2)) {
40810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40811 }
40812 arg2 = static_cast< int >(val2);
40813 {
40814 arg3 = wxString_in_helper(obj2);
40815 if (arg3 == NULL) SWIG_fail;
40816 temp3 = true;
40817 }
40818 if (obj3) {
40819 {
40820 arg4 = wxString_in_helper(obj3);
40821 if (arg4 == NULL) SWIG_fail;
40822 temp4 = true;
40823 }
40824 }
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40828 wxPyEndAllowThreads(__tstate);
40829 if (PyErr_Occurred()) SWIG_fail;
40830 }
40831 {
40832 resultobj = wxPyMake_wxObject(result, (bool)0);
40833 }
40834 {
40835 if (temp3)
40836 delete arg3;
40837 }
40838 {
40839 if (temp4)
40840 delete arg4;
40841 }
40842 return resultobj;
40843 fail:
40844 {
40845 if (temp3)
40846 delete arg3;
40847 }
40848 {
40849 if (temp4)
40850 delete arg4;
40851 }
40852 return NULL;
40853 }
40854
40855
40856 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40857 PyObject *resultobj = 0;
40858 wxMenu *arg1 = (wxMenu *) 0 ;
40859 int arg2 ;
40860 wxString *arg3 = 0 ;
40861 wxMenu *arg4 = (wxMenu *) 0 ;
40862 wxString const &arg5_defvalue = wxPyEmptyString ;
40863 wxString *arg5 = (wxString *) &arg5_defvalue ;
40864 wxMenuItem *result = 0 ;
40865 void *argp1 = 0 ;
40866 int res1 = 0 ;
40867 int val2 ;
40868 int ecode2 = 0 ;
40869 bool temp3 = false ;
40870 void *argp4 = 0 ;
40871 int res4 = 0 ;
40872 bool temp5 = false ;
40873 PyObject * obj0 = 0 ;
40874 PyObject * obj1 = 0 ;
40875 PyObject * obj2 = 0 ;
40876 PyObject * obj3 = 0 ;
40877 PyObject * obj4 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenu * >(argp1);
40888 ecode2 = SWIG_AsVal_int(obj1, &val2);
40889 if (!SWIG_IsOK(ecode2)) {
40890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40891 }
40892 arg2 = static_cast< int >(val2);
40893 {
40894 arg3 = wxString_in_helper(obj2);
40895 if (arg3 == NULL) SWIG_fail;
40896 temp3 = true;
40897 }
40898 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40899 if (!SWIG_IsOK(res4)) {
40900 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40901 }
40902 arg4 = reinterpret_cast< wxMenu * >(argp4);
40903 if (obj4) {
40904 {
40905 arg5 = wxString_in_helper(obj4);
40906 if (arg5 == NULL) SWIG_fail;
40907 temp5 = true;
40908 }
40909 }
40910 {
40911 PyThreadState* __tstate = wxPyBeginAllowThreads();
40912 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40913 wxPyEndAllowThreads(__tstate);
40914 if (PyErr_Occurred()) SWIG_fail;
40915 }
40916 {
40917 resultobj = wxPyMake_wxObject(result, (bool)0);
40918 }
40919 {
40920 if (temp3)
40921 delete arg3;
40922 }
40923 {
40924 if (temp5)
40925 delete arg5;
40926 }
40927 return resultobj;
40928 fail:
40929 {
40930 if (temp3)
40931 delete arg3;
40932 }
40933 {
40934 if (temp5)
40935 delete arg5;
40936 }
40937 return NULL;
40938 }
40939
40940
40941 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 wxMenu *arg1 = (wxMenu *) 0 ;
40944 int arg2 ;
40945 wxMenuItem *result = 0 ;
40946 void *argp1 = 0 ;
40947 int res1 = 0 ;
40948 int val2 ;
40949 int ecode2 = 0 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 char * kwnames[] = {
40953 (char *) "self",(char *) "id", NULL
40954 };
40955
40956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40958 if (!SWIG_IsOK(res1)) {
40959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40960 }
40961 arg1 = reinterpret_cast< wxMenu * >(argp1);
40962 ecode2 = SWIG_AsVal_int(obj1, &val2);
40963 if (!SWIG_IsOK(ecode2)) {
40964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40965 }
40966 arg2 = static_cast< int >(val2);
40967 {
40968 PyThreadState* __tstate = wxPyBeginAllowThreads();
40969 result = (wxMenuItem *)(arg1)->Remove(arg2);
40970 wxPyEndAllowThreads(__tstate);
40971 if (PyErr_Occurred()) SWIG_fail;
40972 }
40973 {
40974 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40975 }
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj = 0;
40984 wxMenu *arg1 = (wxMenu *) 0 ;
40985 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40986 wxMenuItem *result = 0 ;
40987 void *argp1 = 0 ;
40988 int res1 = 0 ;
40989 void *argp2 = 0 ;
40990 int res2 = 0 ;
40991 PyObject * obj0 = 0 ;
40992 PyObject * obj1 = 0 ;
40993 char * kwnames[] = {
40994 (char *) "self",(char *) "item", NULL
40995 };
40996
40997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40999 if (!SWIG_IsOK(res1)) {
41000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41001 }
41002 arg1 = reinterpret_cast< wxMenu * >(argp1);
41003 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41004 if (!SWIG_IsOK(res2)) {
41005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41006 }
41007 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (wxMenuItem *)(arg1)->Remove(arg2);
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
41016 }
41017 return resultobj;
41018 fail:
41019 return NULL;
41020 }
41021
41022
41023 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41024 PyObject *resultobj = 0;
41025 wxMenu *arg1 = (wxMenu *) 0 ;
41026 int arg2 ;
41027 bool result;
41028 void *argp1 = 0 ;
41029 int res1 = 0 ;
41030 int val2 ;
41031 int ecode2 = 0 ;
41032 PyObject * obj0 = 0 ;
41033 PyObject * obj1 = 0 ;
41034 char * kwnames[] = {
41035 (char *) "self",(char *) "id", NULL
41036 };
41037
41038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
41039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41040 if (!SWIG_IsOK(res1)) {
41041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
41042 }
41043 arg1 = reinterpret_cast< wxMenu * >(argp1);
41044 ecode2 = SWIG_AsVal_int(obj1, &val2);
41045 if (!SWIG_IsOK(ecode2)) {
41046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
41047 }
41048 arg2 = static_cast< int >(val2);
41049 {
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (bool)(arg1)->Delete(arg2);
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 {
41056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41057 }
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxMenu *arg1 = (wxMenu *) 0 ;
41067 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41068 bool result;
41069 void *argp1 = 0 ;
41070 int res1 = 0 ;
41071 void *argp2 = 0 ;
41072 int res2 = 0 ;
41073 PyObject * obj0 = 0 ;
41074 PyObject * obj1 = 0 ;
41075 char * kwnames[] = {
41076 (char *) "self",(char *) "item", NULL
41077 };
41078
41079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
41080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41081 if (!SWIG_IsOK(res1)) {
41082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41083 }
41084 arg1 = reinterpret_cast< wxMenu * >(argp1);
41085 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41086 if (!SWIG_IsOK(res2)) {
41087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41088 }
41089 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41090 {
41091 PyThreadState* __tstate = wxPyBeginAllowThreads();
41092 result = (bool)(arg1)->Delete(arg2);
41093 wxPyEndAllowThreads(__tstate);
41094 if (PyErr_Occurred()) SWIG_fail;
41095 }
41096 {
41097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41098 }
41099 return resultobj;
41100 fail:
41101 return NULL;
41102 }
41103
41104
41105 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41106 PyObject *resultobj = 0;
41107 wxMenu *arg1 = (wxMenu *) 0 ;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 PyObject *swig_obj[1] ;
41111
41112 if (!args) SWIG_fail;
41113 swig_obj[0] = args;
41114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
41117 }
41118 arg1 = reinterpret_cast< wxMenu * >(argp1);
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 wxMenu_Destroy(arg1);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 resultobj = SWIG_Py_Void();
41126 return resultobj;
41127 fail:
41128 return NULL;
41129 }
41130
41131
41132 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41133 PyObject *resultobj = 0;
41134 wxMenu *arg1 = (wxMenu *) 0 ;
41135 int arg2 ;
41136 bool result;
41137 void *argp1 = 0 ;
41138 int res1 = 0 ;
41139 int val2 ;
41140 int ecode2 = 0 ;
41141 PyObject * obj0 = 0 ;
41142 PyObject * obj1 = 0 ;
41143 char * kwnames[] = {
41144 (char *) "self",(char *) "id", NULL
41145 };
41146
41147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
41148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41149 if (!SWIG_IsOK(res1)) {
41150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
41151 }
41152 arg1 = reinterpret_cast< wxMenu * >(argp1);
41153 ecode2 = SWIG_AsVal_int(obj1, &val2);
41154 if (!SWIG_IsOK(ecode2)) {
41155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
41156 }
41157 arg2 = static_cast< int >(val2);
41158 {
41159 PyThreadState* __tstate = wxPyBeginAllowThreads();
41160 result = (bool)(arg1)->Destroy(arg2);
41161 wxPyEndAllowThreads(__tstate);
41162 if (PyErr_Occurred()) SWIG_fail;
41163 }
41164 {
41165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41166 }
41167 return resultobj;
41168 fail:
41169 return NULL;
41170 }
41171
41172
41173 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41174 PyObject *resultobj = 0;
41175 wxMenu *arg1 = (wxMenu *) 0 ;
41176 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
41177 bool result;
41178 void *argp1 = 0 ;
41179 int res1 = 0 ;
41180 void *argp2 = 0 ;
41181 int res2 = 0 ;
41182 PyObject * obj0 = 0 ;
41183 PyObject * obj1 = 0 ;
41184 char * kwnames[] = {
41185 (char *) "self",(char *) "item", NULL
41186 };
41187
41188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
41189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41190 if (!SWIG_IsOK(res1)) {
41191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41192 }
41193 arg1 = reinterpret_cast< wxMenu * >(argp1);
41194 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41195 if (!SWIG_IsOK(res2)) {
41196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
41197 }
41198 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
41199 {
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 result = (bool)(arg1)->Destroy(arg2);
41202 wxPyEndAllowThreads(__tstate);
41203 if (PyErr_Occurred()) SWIG_fail;
41204 }
41205 {
41206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41207 }
41208 return resultobj;
41209 fail:
41210 return NULL;
41211 }
41212
41213
41214 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41215 PyObject *resultobj = 0;
41216 wxMenu *arg1 = (wxMenu *) 0 ;
41217 size_t result;
41218 void *argp1 = 0 ;
41219 int res1 = 0 ;
41220 PyObject *swig_obj[1] ;
41221
41222 if (!args) SWIG_fail;
41223 swig_obj[0] = args;
41224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41225 if (!SWIG_IsOK(res1)) {
41226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
41227 }
41228 arg1 = reinterpret_cast< wxMenu * >(argp1);
41229 {
41230 PyThreadState* __tstate = wxPyBeginAllowThreads();
41231 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
41232 wxPyEndAllowThreads(__tstate);
41233 if (PyErr_Occurred()) SWIG_fail;
41234 }
41235 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41236 return resultobj;
41237 fail:
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41243 PyObject *resultobj = 0;
41244 wxMenu *arg1 = (wxMenu *) 0 ;
41245 PyObject *result = 0 ;
41246 void *argp1 = 0 ;
41247 int res1 = 0 ;
41248 PyObject *swig_obj[1] ;
41249
41250 if (!args) SWIG_fail;
41251 swig_obj[0] = args;
41252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
41255 }
41256 arg1 = reinterpret_cast< wxMenu * >(argp1);
41257 {
41258 PyThreadState* __tstate = wxPyBeginAllowThreads();
41259 result = (PyObject *)wxMenu_GetMenuItems(arg1);
41260 wxPyEndAllowThreads(__tstate);
41261 if (PyErr_Occurred()) SWIG_fail;
41262 }
41263 resultobj = result;
41264 return resultobj;
41265 fail:
41266 return NULL;
41267 }
41268
41269
41270 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41271 PyObject *resultobj = 0;
41272 wxMenu *arg1 = (wxMenu *) 0 ;
41273 wxString *arg2 = 0 ;
41274 int result;
41275 void *argp1 = 0 ;
41276 int res1 = 0 ;
41277 bool temp2 = false ;
41278 PyObject * obj0 = 0 ;
41279 PyObject * obj1 = 0 ;
41280 char * kwnames[] = {
41281 (char *) "self",(char *) "item", NULL
41282 };
41283
41284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
41285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41286 if (!SWIG_IsOK(res1)) {
41287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
41288 }
41289 arg1 = reinterpret_cast< wxMenu * >(argp1);
41290 {
41291 arg2 = wxString_in_helper(obj1);
41292 if (arg2 == NULL) SWIG_fail;
41293 temp2 = true;
41294 }
41295 {
41296 PyThreadState* __tstate = wxPyBeginAllowThreads();
41297 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
41298 wxPyEndAllowThreads(__tstate);
41299 if (PyErr_Occurred()) SWIG_fail;
41300 }
41301 resultobj = SWIG_From_int(static_cast< int >(result));
41302 {
41303 if (temp2)
41304 delete arg2;
41305 }
41306 return resultobj;
41307 fail:
41308 {
41309 if (temp2)
41310 delete arg2;
41311 }
41312 return NULL;
41313 }
41314
41315
41316 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41317 PyObject *resultobj = 0;
41318 wxMenu *arg1 = (wxMenu *) 0 ;
41319 int arg2 ;
41320 wxMenuItem *result = 0 ;
41321 void *argp1 = 0 ;
41322 int res1 = 0 ;
41323 int val2 ;
41324 int ecode2 = 0 ;
41325 PyObject * obj0 = 0 ;
41326 PyObject * obj1 = 0 ;
41327 char * kwnames[] = {
41328 (char *) "self",(char *) "id", NULL
41329 };
41330
41331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41333 if (!SWIG_IsOK(res1)) {
41334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
41335 }
41336 arg1 = reinterpret_cast< wxMenu * >(argp1);
41337 ecode2 = SWIG_AsVal_int(obj1, &val2);
41338 if (!SWIG_IsOK(ecode2)) {
41339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
41340 }
41341 arg2 = static_cast< int >(val2);
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 resultobj = wxPyMake_wxObject(result, (bool)0);
41350 }
41351 return resultobj;
41352 fail:
41353 return NULL;
41354 }
41355
41356
41357 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41358 PyObject *resultobj = 0;
41359 wxMenu *arg1 = (wxMenu *) 0 ;
41360 size_t arg2 ;
41361 wxMenuItem *result = 0 ;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 size_t val2 ;
41365 int ecode2 = 0 ;
41366 PyObject * obj0 = 0 ;
41367 PyObject * obj1 = 0 ;
41368 char * kwnames[] = {
41369 (char *) "self",(char *) "position", NULL
41370 };
41371
41372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
41373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41374 if (!SWIG_IsOK(res1)) {
41375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
41376 }
41377 arg1 = reinterpret_cast< wxMenu * >(argp1);
41378 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41379 if (!SWIG_IsOK(ecode2)) {
41380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
41381 }
41382 arg2 = static_cast< size_t >(val2);
41383 {
41384 PyThreadState* __tstate = wxPyBeginAllowThreads();
41385 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 {
41390 resultobj = wxPyMake_wxObject(result, (bool)0);
41391 }
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj = 0;
41400 wxMenu *arg1 = (wxMenu *) 0 ;
41401 int arg2 ;
41402 bool arg3 ;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 int val2 ;
41406 int ecode2 = 0 ;
41407 bool val3 ;
41408 int ecode3 = 0 ;
41409 PyObject * obj0 = 0 ;
41410 PyObject * obj1 = 0 ;
41411 PyObject * obj2 = 0 ;
41412 char * kwnames[] = {
41413 (char *) "self",(char *) "id",(char *) "enable", NULL
41414 };
41415
41416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41418 if (!SWIG_IsOK(res1)) {
41419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
41420 }
41421 arg1 = reinterpret_cast< wxMenu * >(argp1);
41422 ecode2 = SWIG_AsVal_int(obj1, &val2);
41423 if (!SWIG_IsOK(ecode2)) {
41424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
41425 }
41426 arg2 = static_cast< int >(val2);
41427 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41428 if (!SWIG_IsOK(ecode3)) {
41429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
41430 }
41431 arg3 = static_cast< bool >(val3);
41432 {
41433 PyThreadState* __tstate = wxPyBeginAllowThreads();
41434 (arg1)->Enable(arg2,arg3);
41435 wxPyEndAllowThreads(__tstate);
41436 if (PyErr_Occurred()) SWIG_fail;
41437 }
41438 resultobj = SWIG_Py_Void();
41439 return resultobj;
41440 fail:
41441 return NULL;
41442 }
41443
41444
41445 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41446 PyObject *resultobj = 0;
41447 wxMenu *arg1 = (wxMenu *) 0 ;
41448 int arg2 ;
41449 bool result;
41450 void *argp1 = 0 ;
41451 int res1 = 0 ;
41452 int val2 ;
41453 int ecode2 = 0 ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 char * kwnames[] = {
41457 (char *) "self",(char *) "id", NULL
41458 };
41459
41460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41462 if (!SWIG_IsOK(res1)) {
41463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
41464 }
41465 arg1 = reinterpret_cast< wxMenu * >(argp1);
41466 ecode2 = SWIG_AsVal_int(obj1, &val2);
41467 if (!SWIG_IsOK(ecode2)) {
41468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41469 }
41470 arg2 = static_cast< int >(val2);
41471 {
41472 PyThreadState* __tstate = wxPyBeginAllowThreads();
41473 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
41474 wxPyEndAllowThreads(__tstate);
41475 if (PyErr_Occurred()) SWIG_fail;
41476 }
41477 {
41478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41479 }
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = 0;
41488 wxMenu *arg1 = (wxMenu *) 0 ;
41489 int arg2 ;
41490 bool arg3 ;
41491 void *argp1 = 0 ;
41492 int res1 = 0 ;
41493 int val2 ;
41494 int ecode2 = 0 ;
41495 bool val3 ;
41496 int ecode3 = 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 PyObject * obj2 = 0 ;
41500 char * kwnames[] = {
41501 (char *) "self",(char *) "id",(char *) "check", NULL
41502 };
41503
41504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41506 if (!SWIG_IsOK(res1)) {
41507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41508 }
41509 arg1 = reinterpret_cast< wxMenu * >(argp1);
41510 ecode2 = SWIG_AsVal_int(obj1, &val2);
41511 if (!SWIG_IsOK(ecode2)) {
41512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41513 }
41514 arg2 = static_cast< int >(val2);
41515 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41516 if (!SWIG_IsOK(ecode3)) {
41517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41518 }
41519 arg3 = static_cast< bool >(val3);
41520 {
41521 PyThreadState* __tstate = wxPyBeginAllowThreads();
41522 (arg1)->Check(arg2,arg3);
41523 wxPyEndAllowThreads(__tstate);
41524 if (PyErr_Occurred()) SWIG_fail;
41525 }
41526 resultobj = SWIG_Py_Void();
41527 return resultobj;
41528 fail:
41529 return NULL;
41530 }
41531
41532
41533 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41534 PyObject *resultobj = 0;
41535 wxMenu *arg1 = (wxMenu *) 0 ;
41536 int arg2 ;
41537 bool result;
41538 void *argp1 = 0 ;
41539 int res1 = 0 ;
41540 int val2 ;
41541 int ecode2 = 0 ;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 char * kwnames[] = {
41545 (char *) "self",(char *) "id", NULL
41546 };
41547
41548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41550 if (!SWIG_IsOK(res1)) {
41551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41552 }
41553 arg1 = reinterpret_cast< wxMenu * >(argp1);
41554 ecode2 = SWIG_AsVal_int(obj1, &val2);
41555 if (!SWIG_IsOK(ecode2)) {
41556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41557 }
41558 arg2 = static_cast< int >(val2);
41559 {
41560 PyThreadState* __tstate = wxPyBeginAllowThreads();
41561 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41562 wxPyEndAllowThreads(__tstate);
41563 if (PyErr_Occurred()) SWIG_fail;
41564 }
41565 {
41566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41567 }
41568 return resultobj;
41569 fail:
41570 return NULL;
41571 }
41572
41573
41574 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41575 PyObject *resultobj = 0;
41576 wxMenu *arg1 = (wxMenu *) 0 ;
41577 int arg2 ;
41578 wxString *arg3 = 0 ;
41579 void *argp1 = 0 ;
41580 int res1 = 0 ;
41581 int val2 ;
41582 int ecode2 = 0 ;
41583 bool temp3 = false ;
41584 PyObject * obj0 = 0 ;
41585 PyObject * obj1 = 0 ;
41586 PyObject * obj2 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "id",(char *) "label", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41595 }
41596 arg1 = reinterpret_cast< wxMenu * >(argp1);
41597 ecode2 = SWIG_AsVal_int(obj1, &val2);
41598 if (!SWIG_IsOK(ecode2)) {
41599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41600 }
41601 arg2 = static_cast< int >(val2);
41602 {
41603 arg3 = wxString_in_helper(obj2);
41604 if (arg3 == NULL) SWIG_fail;
41605 temp3 = true;
41606 }
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41610 wxPyEndAllowThreads(__tstate);
41611 if (PyErr_Occurred()) SWIG_fail;
41612 }
41613 resultobj = SWIG_Py_Void();
41614 {
41615 if (temp3)
41616 delete arg3;
41617 }
41618 return resultobj;
41619 fail:
41620 {
41621 if (temp3)
41622 delete arg3;
41623 }
41624 return NULL;
41625 }
41626
41627
41628 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41629 PyObject *resultobj = 0;
41630 wxMenu *arg1 = (wxMenu *) 0 ;
41631 int arg2 ;
41632 wxString result;
41633 void *argp1 = 0 ;
41634 int res1 = 0 ;
41635 int val2 ;
41636 int ecode2 = 0 ;
41637 PyObject * obj0 = 0 ;
41638 PyObject * obj1 = 0 ;
41639 char * kwnames[] = {
41640 (char *) "self",(char *) "id", NULL
41641 };
41642
41643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41645 if (!SWIG_IsOK(res1)) {
41646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41647 }
41648 arg1 = reinterpret_cast< wxMenu * >(argp1);
41649 ecode2 = SWIG_AsVal_int(obj1, &val2);
41650 if (!SWIG_IsOK(ecode2)) {
41651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41652 }
41653 arg2 = static_cast< int >(val2);
41654 {
41655 PyThreadState* __tstate = wxPyBeginAllowThreads();
41656 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41657 wxPyEndAllowThreads(__tstate);
41658 if (PyErr_Occurred()) SWIG_fail;
41659 }
41660 {
41661 #if wxUSE_UNICODE
41662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41663 #else
41664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41665 #endif
41666 }
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj = 0;
41675 wxMenu *arg1 = (wxMenu *) 0 ;
41676 int arg2 ;
41677 wxString *arg3 = 0 ;
41678 void *argp1 = 0 ;
41679 int res1 = 0 ;
41680 int val2 ;
41681 int ecode2 = 0 ;
41682 bool temp3 = false ;
41683 PyObject * obj0 = 0 ;
41684 PyObject * obj1 = 0 ;
41685 PyObject * obj2 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "self",(char *) "id",(char *) "helpString", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41692 if (!SWIG_IsOK(res1)) {
41693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41694 }
41695 arg1 = reinterpret_cast< wxMenu * >(argp1);
41696 ecode2 = SWIG_AsVal_int(obj1, &val2);
41697 if (!SWIG_IsOK(ecode2)) {
41698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41699 }
41700 arg2 = static_cast< int >(val2);
41701 {
41702 arg3 = wxString_in_helper(obj2);
41703 if (arg3 == NULL) SWIG_fail;
41704 temp3 = true;
41705 }
41706 {
41707 PyThreadState* __tstate = wxPyBeginAllowThreads();
41708 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 resultobj = SWIG_Py_Void();
41713 {
41714 if (temp3)
41715 delete arg3;
41716 }
41717 return resultobj;
41718 fail:
41719 {
41720 if (temp3)
41721 delete arg3;
41722 }
41723 return NULL;
41724 }
41725
41726
41727 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41728 PyObject *resultobj = 0;
41729 wxMenu *arg1 = (wxMenu *) 0 ;
41730 int arg2 ;
41731 wxString result;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 int val2 ;
41735 int ecode2 = 0 ;
41736 PyObject * obj0 = 0 ;
41737 PyObject * obj1 = 0 ;
41738 char * kwnames[] = {
41739 (char *) "self",(char *) "id", NULL
41740 };
41741
41742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41744 if (!SWIG_IsOK(res1)) {
41745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41746 }
41747 arg1 = reinterpret_cast< wxMenu * >(argp1);
41748 ecode2 = SWIG_AsVal_int(obj1, &val2);
41749 if (!SWIG_IsOK(ecode2)) {
41750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41751 }
41752 arg2 = static_cast< int >(val2);
41753 {
41754 PyThreadState* __tstate = wxPyBeginAllowThreads();
41755 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41756 wxPyEndAllowThreads(__tstate);
41757 if (PyErr_Occurred()) SWIG_fail;
41758 }
41759 {
41760 #if wxUSE_UNICODE
41761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41762 #else
41763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41764 #endif
41765 }
41766 return resultobj;
41767 fail:
41768 return NULL;
41769 }
41770
41771
41772 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41773 PyObject *resultobj = 0;
41774 wxMenu *arg1 = (wxMenu *) 0 ;
41775 wxString *arg2 = 0 ;
41776 void *argp1 = 0 ;
41777 int res1 = 0 ;
41778 bool temp2 = false ;
41779 PyObject * obj0 = 0 ;
41780 PyObject * obj1 = 0 ;
41781 char * kwnames[] = {
41782 (char *) "self",(char *) "title", NULL
41783 };
41784
41785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41787 if (!SWIG_IsOK(res1)) {
41788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41789 }
41790 arg1 = reinterpret_cast< wxMenu * >(argp1);
41791 {
41792 arg2 = wxString_in_helper(obj1);
41793 if (arg2 == NULL) SWIG_fail;
41794 temp2 = true;
41795 }
41796 {
41797 PyThreadState* __tstate = wxPyBeginAllowThreads();
41798 (arg1)->SetTitle((wxString const &)*arg2);
41799 wxPyEndAllowThreads(__tstate);
41800 if (PyErr_Occurred()) SWIG_fail;
41801 }
41802 resultobj = SWIG_Py_Void();
41803 {
41804 if (temp2)
41805 delete arg2;
41806 }
41807 return resultobj;
41808 fail:
41809 {
41810 if (temp2)
41811 delete arg2;
41812 }
41813 return NULL;
41814 }
41815
41816
41817 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41818 PyObject *resultobj = 0;
41819 wxMenu *arg1 = (wxMenu *) 0 ;
41820 wxString result;
41821 void *argp1 = 0 ;
41822 int res1 = 0 ;
41823 PyObject *swig_obj[1] ;
41824
41825 if (!args) SWIG_fail;
41826 swig_obj[0] = args;
41827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41828 if (!SWIG_IsOK(res1)) {
41829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41830 }
41831 arg1 = reinterpret_cast< wxMenu * >(argp1);
41832 {
41833 PyThreadState* __tstate = wxPyBeginAllowThreads();
41834 result = ((wxMenu const *)arg1)->GetTitle();
41835 wxPyEndAllowThreads(__tstate);
41836 if (PyErr_Occurred()) SWIG_fail;
41837 }
41838 {
41839 #if wxUSE_UNICODE
41840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41841 #else
41842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41843 #endif
41844 }
41845 return resultobj;
41846 fail:
41847 return NULL;
41848 }
41849
41850
41851 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41852 PyObject *resultobj = 0;
41853 wxMenu *arg1 = (wxMenu *) 0 ;
41854 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41855 void *argp1 = 0 ;
41856 int res1 = 0 ;
41857 void *argp2 = 0 ;
41858 int res2 = 0 ;
41859 PyObject * obj0 = 0 ;
41860 PyObject * obj1 = 0 ;
41861 char * kwnames[] = {
41862 (char *) "self",(char *) "handler", NULL
41863 };
41864
41865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41867 if (!SWIG_IsOK(res1)) {
41868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41869 }
41870 arg1 = reinterpret_cast< wxMenu * >(argp1);
41871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41872 if (!SWIG_IsOK(res2)) {
41873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41874 }
41875 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41876 {
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 (arg1)->SetEventHandler(arg2);
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 resultobj = SWIG_Py_Void();
41883 return resultobj;
41884 fail:
41885 return NULL;
41886 }
41887
41888
41889 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41890 PyObject *resultobj = 0;
41891 wxMenu *arg1 = (wxMenu *) 0 ;
41892 wxEvtHandler *result = 0 ;
41893 void *argp1 = 0 ;
41894 int res1 = 0 ;
41895 PyObject *swig_obj[1] ;
41896
41897 if (!args) SWIG_fail;
41898 swig_obj[0] = args;
41899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenu * >(argp1);
41904 {
41905 PyThreadState* __tstate = wxPyBeginAllowThreads();
41906 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41907 wxPyEndAllowThreads(__tstate);
41908 if (PyErr_Occurred()) SWIG_fail;
41909 }
41910 {
41911 resultobj = wxPyMake_wxObject(result, 0);
41912 }
41913 return resultobj;
41914 fail:
41915 return NULL;
41916 }
41917
41918
41919 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41920 PyObject *resultobj = 0;
41921 wxMenu *arg1 = (wxMenu *) 0 ;
41922 wxWindow *arg2 = (wxWindow *) 0 ;
41923 void *argp1 = 0 ;
41924 int res1 = 0 ;
41925 void *argp2 = 0 ;
41926 int res2 = 0 ;
41927 PyObject * obj0 = 0 ;
41928 PyObject * obj1 = 0 ;
41929 char * kwnames[] = {
41930 (char *) "self",(char *) "win", NULL
41931 };
41932
41933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41935 if (!SWIG_IsOK(res1)) {
41936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41937 }
41938 arg1 = reinterpret_cast< wxMenu * >(argp1);
41939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41940 if (!SWIG_IsOK(res2)) {
41941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41942 }
41943 arg2 = reinterpret_cast< wxWindow * >(argp2);
41944 {
41945 PyThreadState* __tstate = wxPyBeginAllowThreads();
41946 (arg1)->SetInvokingWindow(arg2);
41947 wxPyEndAllowThreads(__tstate);
41948 if (PyErr_Occurred()) SWIG_fail;
41949 }
41950 resultobj = SWIG_Py_Void();
41951 return resultobj;
41952 fail:
41953 return NULL;
41954 }
41955
41956
41957 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41958 PyObject *resultobj = 0;
41959 wxMenu *arg1 = (wxMenu *) 0 ;
41960 wxWindow *result = 0 ;
41961 void *argp1 = 0 ;
41962 int res1 = 0 ;
41963 PyObject *swig_obj[1] ;
41964
41965 if (!args) SWIG_fail;
41966 swig_obj[0] = args;
41967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41968 if (!SWIG_IsOK(res1)) {
41969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41970 }
41971 arg1 = reinterpret_cast< wxMenu * >(argp1);
41972 {
41973 PyThreadState* __tstate = wxPyBeginAllowThreads();
41974 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41975 wxPyEndAllowThreads(__tstate);
41976 if (PyErr_Occurred()) SWIG_fail;
41977 }
41978 {
41979 resultobj = wxPyMake_wxObject(result, 0);
41980 }
41981 return resultobj;
41982 fail:
41983 return NULL;
41984 }
41985
41986
41987 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41988 PyObject *resultobj = 0;
41989 wxMenu *arg1 = (wxMenu *) 0 ;
41990 long result;
41991 void *argp1 = 0 ;
41992 int res1 = 0 ;
41993 PyObject *swig_obj[1] ;
41994
41995 if (!args) SWIG_fail;
41996 swig_obj[0] = args;
41997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41998 if (!SWIG_IsOK(res1)) {
41999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
42000 }
42001 arg1 = reinterpret_cast< wxMenu * >(argp1);
42002 {
42003 PyThreadState* __tstate = wxPyBeginAllowThreads();
42004 result = (long)((wxMenu const *)arg1)->GetStyle();
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 resultobj = SWIG_From_long(static_cast< long >(result));
42009 return resultobj;
42010 fail:
42011 return NULL;
42012 }
42013
42014
42015 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42016 PyObject *resultobj = 0;
42017 wxMenu *arg1 = (wxMenu *) 0 ;
42018 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
42019 void *argp1 = 0 ;
42020 int res1 = 0 ;
42021 void *argp2 = 0 ;
42022 int res2 = 0 ;
42023 PyObject * obj0 = 0 ;
42024 PyObject * obj1 = 0 ;
42025 char * kwnames[] = {
42026 (char *) "self",(char *) "source", NULL
42027 };
42028
42029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
42030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42031 if (!SWIG_IsOK(res1)) {
42032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
42033 }
42034 arg1 = reinterpret_cast< wxMenu * >(argp1);
42035 if (obj1) {
42036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
42037 if (!SWIG_IsOK(res2)) {
42038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
42039 }
42040 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
42041 }
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 (arg1)->UpdateUI(arg2);
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 resultobj = SWIG_Py_Void();
42049 return resultobj;
42050 fail:
42051 return NULL;
42052 }
42053
42054
42055 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42056 PyObject *resultobj = 0;
42057 wxMenu *arg1 = (wxMenu *) 0 ;
42058 wxMenuBar *result = 0 ;
42059 void *argp1 = 0 ;
42060 int res1 = 0 ;
42061 PyObject *swig_obj[1] ;
42062
42063 if (!args) SWIG_fail;
42064 swig_obj[0] = args;
42065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42066 if (!SWIG_IsOK(res1)) {
42067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
42068 }
42069 arg1 = reinterpret_cast< wxMenu * >(argp1);
42070 {
42071 PyThreadState* __tstate = wxPyBeginAllowThreads();
42072 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
42073 wxPyEndAllowThreads(__tstate);
42074 if (PyErr_Occurred()) SWIG_fail;
42075 }
42076 {
42077 resultobj = wxPyMake_wxObject(result, (bool)0);
42078 }
42079 return resultobj;
42080 fail:
42081 return NULL;
42082 }
42083
42084
42085 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42086 PyObject *resultobj = 0;
42087 wxMenu *arg1 = (wxMenu *) 0 ;
42088 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
42089 void *argp1 = 0 ;
42090 int res1 = 0 ;
42091 void *argp2 = 0 ;
42092 int res2 = 0 ;
42093 PyObject * obj0 = 0 ;
42094 PyObject * obj1 = 0 ;
42095 char * kwnames[] = {
42096 (char *) "self",(char *) "menubar", NULL
42097 };
42098
42099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42101 if (!SWIG_IsOK(res1)) {
42102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
42103 }
42104 arg1 = reinterpret_cast< wxMenu * >(argp1);
42105 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
42106 if (!SWIG_IsOK(res2)) {
42107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
42108 }
42109 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
42110 {
42111 PyThreadState* __tstate = wxPyBeginAllowThreads();
42112 (arg1)->Attach(arg2);
42113 wxPyEndAllowThreads(__tstate);
42114 if (PyErr_Occurred()) SWIG_fail;
42115 }
42116 resultobj = SWIG_Py_Void();
42117 return resultobj;
42118 fail:
42119 return NULL;
42120 }
42121
42122
42123 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42124 PyObject *resultobj = 0;
42125 wxMenu *arg1 = (wxMenu *) 0 ;
42126 void *argp1 = 0 ;
42127 int res1 = 0 ;
42128 PyObject *swig_obj[1] ;
42129
42130 if (!args) SWIG_fail;
42131 swig_obj[0] = args;
42132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42133 if (!SWIG_IsOK(res1)) {
42134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
42135 }
42136 arg1 = reinterpret_cast< wxMenu * >(argp1);
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 (arg1)->Detach();
42140 wxPyEndAllowThreads(__tstate);
42141 if (PyErr_Occurred()) SWIG_fail;
42142 }
42143 resultobj = SWIG_Py_Void();
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42151 PyObject *resultobj = 0;
42152 wxMenu *arg1 = (wxMenu *) 0 ;
42153 bool result;
42154 void *argp1 = 0 ;
42155 int res1 = 0 ;
42156 PyObject *swig_obj[1] ;
42157
42158 if (!args) SWIG_fail;
42159 swig_obj[0] = args;
42160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42161 if (!SWIG_IsOK(res1)) {
42162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
42163 }
42164 arg1 = reinterpret_cast< wxMenu * >(argp1);
42165 {
42166 PyThreadState* __tstate = wxPyBeginAllowThreads();
42167 result = (bool)((wxMenu const *)arg1)->IsAttached();
42168 wxPyEndAllowThreads(__tstate);
42169 if (PyErr_Occurred()) SWIG_fail;
42170 }
42171 {
42172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42173 }
42174 return resultobj;
42175 fail:
42176 return NULL;
42177 }
42178
42179
42180 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42181 PyObject *resultobj = 0;
42182 wxMenu *arg1 = (wxMenu *) 0 ;
42183 wxMenu *arg2 = (wxMenu *) 0 ;
42184 void *argp1 = 0 ;
42185 int res1 = 0 ;
42186 void *argp2 = 0 ;
42187 int res2 = 0 ;
42188 PyObject * obj0 = 0 ;
42189 PyObject * obj1 = 0 ;
42190 char * kwnames[] = {
42191 (char *) "self",(char *) "parent", NULL
42192 };
42193
42194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
42195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42196 if (!SWIG_IsOK(res1)) {
42197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
42198 }
42199 arg1 = reinterpret_cast< wxMenu * >(argp1);
42200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42201 if (!SWIG_IsOK(res2)) {
42202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
42203 }
42204 arg2 = reinterpret_cast< wxMenu * >(argp2);
42205 {
42206 PyThreadState* __tstate = wxPyBeginAllowThreads();
42207 (arg1)->SetParent(arg2);
42208 wxPyEndAllowThreads(__tstate);
42209 if (PyErr_Occurred()) SWIG_fail;
42210 }
42211 resultobj = SWIG_Py_Void();
42212 return resultobj;
42213 fail:
42214 return NULL;
42215 }
42216
42217
42218 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42219 PyObject *resultobj = 0;
42220 wxMenu *arg1 = (wxMenu *) 0 ;
42221 wxMenu *result = 0 ;
42222 void *argp1 = 0 ;
42223 int res1 = 0 ;
42224 PyObject *swig_obj[1] ;
42225
42226 if (!args) SWIG_fail;
42227 swig_obj[0] = args;
42228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42229 if (!SWIG_IsOK(res1)) {
42230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
42231 }
42232 arg1 = reinterpret_cast< wxMenu * >(argp1);
42233 {
42234 PyThreadState* __tstate = wxPyBeginAllowThreads();
42235 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
42236 wxPyEndAllowThreads(__tstate);
42237 if (PyErr_Occurred()) SWIG_fail;
42238 }
42239 {
42240 resultobj = wxPyMake_wxObject(result, 0);
42241 }
42242 return resultobj;
42243 fail:
42244 return NULL;
42245 }
42246
42247
42248 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42249 PyObject *obj;
42250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42251 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
42252 return SWIG_Py_Void();
42253 }
42254
42255 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42256 return SWIG_Python_InitShadowInstance(args);
42257 }
42258
42259 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42260 PyObject *resultobj = 0;
42261 long arg1 = (long) 0 ;
42262 wxMenuBar *result = 0 ;
42263 long val1 ;
42264 int ecode1 = 0 ;
42265 PyObject * obj0 = 0 ;
42266 char * kwnames[] = {
42267 (char *) "style", NULL
42268 };
42269
42270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
42271 if (obj0) {
42272 ecode1 = SWIG_AsVal_long(obj0, &val1);
42273 if (!SWIG_IsOK(ecode1)) {
42274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
42275 }
42276 arg1 = static_cast< long >(val1);
42277 }
42278 {
42279 if (!wxPyCheckForApp()) SWIG_fail;
42280 PyThreadState* __tstate = wxPyBeginAllowThreads();
42281 result = (wxMenuBar *)new wxMenuBar(arg1);
42282 wxPyEndAllowThreads(__tstate);
42283 if (PyErr_Occurred()) SWIG_fail;
42284 }
42285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
42286 return resultobj;
42287 fail:
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42293 PyObject *resultobj = 0;
42294 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42295 wxMenu *arg2 = (wxMenu *) 0 ;
42296 wxString *arg3 = 0 ;
42297 bool result;
42298 void *argp1 = 0 ;
42299 int res1 = 0 ;
42300 void *argp2 = 0 ;
42301 int res2 = 0 ;
42302 bool temp3 = false ;
42303 PyObject * obj0 = 0 ;
42304 PyObject * obj1 = 0 ;
42305 PyObject * obj2 = 0 ;
42306 char * kwnames[] = {
42307 (char *) "self",(char *) "menu",(char *) "title", NULL
42308 };
42309
42310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42312 if (!SWIG_IsOK(res1)) {
42313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42314 }
42315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42317 if (!SWIG_IsOK(res2)) {
42318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
42319 }
42320 arg2 = reinterpret_cast< wxMenu * >(argp2);
42321 {
42322 arg3 = wxString_in_helper(obj2);
42323 if (arg3 == NULL) SWIG_fail;
42324 temp3 = true;
42325 }
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
42329 wxPyEndAllowThreads(__tstate);
42330 if (PyErr_Occurred()) SWIG_fail;
42331 }
42332 {
42333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42334 }
42335 {
42336 if (temp3)
42337 delete arg3;
42338 }
42339 return resultobj;
42340 fail:
42341 {
42342 if (temp3)
42343 delete arg3;
42344 }
42345 return NULL;
42346 }
42347
42348
42349 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42350 PyObject *resultobj = 0;
42351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42352 size_t arg2 ;
42353 wxMenu *arg3 = (wxMenu *) 0 ;
42354 wxString *arg4 = 0 ;
42355 bool result;
42356 void *argp1 = 0 ;
42357 int res1 = 0 ;
42358 size_t val2 ;
42359 int ecode2 = 0 ;
42360 void *argp3 = 0 ;
42361 int res3 = 0 ;
42362 bool temp4 = false ;
42363 PyObject * obj0 = 0 ;
42364 PyObject * obj1 = 0 ;
42365 PyObject * obj2 = 0 ;
42366 PyObject * obj3 = 0 ;
42367 char * kwnames[] = {
42368 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42369 };
42370
42371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42373 if (!SWIG_IsOK(res1)) {
42374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42375 }
42376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42377 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42378 if (!SWIG_IsOK(ecode2)) {
42379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
42380 }
42381 arg2 = static_cast< size_t >(val2);
42382 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42383 if (!SWIG_IsOK(res3)) {
42384 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
42385 }
42386 arg3 = reinterpret_cast< wxMenu * >(argp3);
42387 {
42388 arg4 = wxString_in_helper(obj3);
42389 if (arg4 == NULL) SWIG_fail;
42390 temp4 = true;
42391 }
42392 {
42393 PyThreadState* __tstate = wxPyBeginAllowThreads();
42394 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
42395 wxPyEndAllowThreads(__tstate);
42396 if (PyErr_Occurred()) SWIG_fail;
42397 }
42398 {
42399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42400 }
42401 {
42402 if (temp4)
42403 delete arg4;
42404 }
42405 return resultobj;
42406 fail:
42407 {
42408 if (temp4)
42409 delete arg4;
42410 }
42411 return NULL;
42412 }
42413
42414
42415 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42416 PyObject *resultobj = 0;
42417 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42418 size_t result;
42419 void *argp1 = 0 ;
42420 int res1 = 0 ;
42421 PyObject *swig_obj[1] ;
42422
42423 if (!args) SWIG_fail;
42424 swig_obj[0] = args;
42425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42426 if (!SWIG_IsOK(res1)) {
42427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42428 }
42429 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42430 {
42431 PyThreadState* __tstate = wxPyBeginAllowThreads();
42432 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
42433 wxPyEndAllowThreads(__tstate);
42434 if (PyErr_Occurred()) SWIG_fail;
42435 }
42436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
42437 return resultobj;
42438 fail:
42439 return NULL;
42440 }
42441
42442
42443 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42444 PyObject *resultobj = 0;
42445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42446 size_t arg2 ;
42447 wxMenu *result = 0 ;
42448 void *argp1 = 0 ;
42449 int res1 = 0 ;
42450 size_t val2 ;
42451 int ecode2 = 0 ;
42452 PyObject * obj0 = 0 ;
42453 PyObject * obj1 = 0 ;
42454 char * kwnames[] = {
42455 (char *) "self",(char *) "pos", NULL
42456 };
42457
42458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42460 if (!SWIG_IsOK(res1)) {
42461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42462 }
42463 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42464 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42465 if (!SWIG_IsOK(ecode2)) {
42466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
42467 }
42468 arg2 = static_cast< size_t >(val2);
42469 {
42470 PyThreadState* __tstate = wxPyBeginAllowThreads();
42471 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
42472 wxPyEndAllowThreads(__tstate);
42473 if (PyErr_Occurred()) SWIG_fail;
42474 }
42475 {
42476 resultobj = wxPyMake_wxObject(result, 0);
42477 }
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj = 0;
42486 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42487 size_t arg2 ;
42488 wxMenu *arg3 = (wxMenu *) 0 ;
42489 wxString *arg4 = 0 ;
42490 wxMenu *result = 0 ;
42491 void *argp1 = 0 ;
42492 int res1 = 0 ;
42493 size_t val2 ;
42494 int ecode2 = 0 ;
42495 void *argp3 = 0 ;
42496 int res3 = 0 ;
42497 bool temp4 = false ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 PyObject * obj2 = 0 ;
42501 PyObject * obj3 = 0 ;
42502 char * kwnames[] = {
42503 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42504 };
42505
42506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42510 }
42511 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42512 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42513 if (!SWIG_IsOK(ecode2)) {
42514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42515 }
42516 arg2 = static_cast< size_t >(val2);
42517 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42518 if (!SWIG_IsOK(res3)) {
42519 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42520 }
42521 arg3 = reinterpret_cast< wxMenu * >(argp3);
42522 {
42523 arg4 = wxString_in_helper(obj3);
42524 if (arg4 == NULL) SWIG_fail;
42525 temp4 = true;
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 {
42534 resultobj = wxPyMake_wxObject(result, 0);
42535 }
42536 {
42537 if (temp4)
42538 delete arg4;
42539 }
42540 return resultobj;
42541 fail:
42542 {
42543 if (temp4)
42544 delete arg4;
42545 }
42546 return NULL;
42547 }
42548
42549
42550 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42551 PyObject *resultobj = 0;
42552 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42553 size_t arg2 ;
42554 wxMenu *result = 0 ;
42555 void *argp1 = 0 ;
42556 int res1 = 0 ;
42557 size_t val2 ;
42558 int ecode2 = 0 ;
42559 PyObject * obj0 = 0 ;
42560 PyObject * obj1 = 0 ;
42561 char * kwnames[] = {
42562 (char *) "self",(char *) "pos", NULL
42563 };
42564
42565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42567 if (!SWIG_IsOK(res1)) {
42568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42569 }
42570 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42571 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42572 if (!SWIG_IsOK(ecode2)) {
42573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42574 }
42575 arg2 = static_cast< size_t >(val2);
42576 {
42577 PyThreadState* __tstate = wxPyBeginAllowThreads();
42578 result = (wxMenu *)(arg1)->Remove(arg2);
42579 wxPyEndAllowThreads(__tstate);
42580 if (PyErr_Occurred()) SWIG_fail;
42581 }
42582 {
42583 resultobj = wxPyMake_wxObject(result, 0);
42584 }
42585 return resultobj;
42586 fail:
42587 return NULL;
42588 }
42589
42590
42591 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42592 PyObject *resultobj = 0;
42593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42594 size_t arg2 ;
42595 bool arg3 ;
42596 void *argp1 = 0 ;
42597 int res1 = 0 ;
42598 size_t val2 ;
42599 int ecode2 = 0 ;
42600 bool val3 ;
42601 int ecode3 = 0 ;
42602 PyObject * obj0 = 0 ;
42603 PyObject * obj1 = 0 ;
42604 PyObject * obj2 = 0 ;
42605 char * kwnames[] = {
42606 (char *) "self",(char *) "pos",(char *) "enable", NULL
42607 };
42608
42609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42611 if (!SWIG_IsOK(res1)) {
42612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42613 }
42614 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42616 if (!SWIG_IsOK(ecode2)) {
42617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42618 }
42619 arg2 = static_cast< size_t >(val2);
42620 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42621 if (!SWIG_IsOK(ecode3)) {
42622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42623 }
42624 arg3 = static_cast< bool >(val3);
42625 {
42626 PyThreadState* __tstate = wxPyBeginAllowThreads();
42627 (arg1)->EnableTop(arg2,arg3);
42628 wxPyEndAllowThreads(__tstate);
42629 if (PyErr_Occurred()) SWIG_fail;
42630 }
42631 resultobj = SWIG_Py_Void();
42632 return resultobj;
42633 fail:
42634 return NULL;
42635 }
42636
42637
42638 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42639 PyObject *resultobj = 0;
42640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42641 size_t arg2 ;
42642 bool result;
42643 void *argp1 = 0 ;
42644 int res1 = 0 ;
42645 size_t val2 ;
42646 int ecode2 = 0 ;
42647 PyObject * obj0 = 0 ;
42648 PyObject * obj1 = 0 ;
42649 char * kwnames[] = {
42650 (char *) "self",(char *) "pos", NULL
42651 };
42652
42653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42655 if (!SWIG_IsOK(res1)) {
42656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42657 }
42658 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42659 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42660 if (!SWIG_IsOK(ecode2)) {
42661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42662 }
42663 arg2 = static_cast< size_t >(val2);
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42667 wxPyEndAllowThreads(__tstate);
42668 if (PyErr_Occurred()) SWIG_fail;
42669 }
42670 {
42671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42672 }
42673 return resultobj;
42674 fail:
42675 return NULL;
42676 }
42677
42678
42679 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42680 PyObject *resultobj = 0;
42681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42682 size_t arg2 ;
42683 wxString *arg3 = 0 ;
42684 void *argp1 = 0 ;
42685 int res1 = 0 ;
42686 size_t val2 ;
42687 int ecode2 = 0 ;
42688 bool temp3 = false ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 PyObject * obj2 = 0 ;
42692 char * kwnames[] = {
42693 (char *) "self",(char *) "pos",(char *) "label", NULL
42694 };
42695
42696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42698 if (!SWIG_IsOK(res1)) {
42699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42700 }
42701 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42702 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42703 if (!SWIG_IsOK(ecode2)) {
42704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42705 }
42706 arg2 = static_cast< size_t >(val2);
42707 {
42708 arg3 = wxString_in_helper(obj2);
42709 if (arg3 == NULL) SWIG_fail;
42710 temp3 = true;
42711 }
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 resultobj = SWIG_Py_Void();
42719 {
42720 if (temp3)
42721 delete arg3;
42722 }
42723 return resultobj;
42724 fail:
42725 {
42726 if (temp3)
42727 delete arg3;
42728 }
42729 return NULL;
42730 }
42731
42732
42733 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42734 PyObject *resultobj = 0;
42735 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42736 size_t arg2 ;
42737 wxString result;
42738 void *argp1 = 0 ;
42739 int res1 = 0 ;
42740 size_t val2 ;
42741 int ecode2 = 0 ;
42742 PyObject * obj0 = 0 ;
42743 PyObject * obj1 = 0 ;
42744 char * kwnames[] = {
42745 (char *) "self",(char *) "pos", NULL
42746 };
42747
42748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42750 if (!SWIG_IsOK(res1)) {
42751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42752 }
42753 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42754 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42755 if (!SWIG_IsOK(ecode2)) {
42756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42757 }
42758 arg2 = static_cast< size_t >(val2);
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 {
42766 #if wxUSE_UNICODE
42767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42768 #else
42769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42770 #endif
42771 }
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = 0;
42780 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42781 wxString *arg2 = 0 ;
42782 wxString *arg3 = 0 ;
42783 int result;
42784 void *argp1 = 0 ;
42785 int res1 = 0 ;
42786 bool temp2 = false ;
42787 bool temp3 = false ;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790 PyObject * obj2 = 0 ;
42791 char * kwnames[] = {
42792 (char *) "self",(char *) "menu",(char *) "item", NULL
42793 };
42794
42795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42797 if (!SWIG_IsOK(res1)) {
42798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42799 }
42800 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42801 {
42802 arg2 = wxString_in_helper(obj1);
42803 if (arg2 == NULL) SWIG_fail;
42804 temp2 = true;
42805 }
42806 {
42807 arg3 = wxString_in_helper(obj2);
42808 if (arg3 == NULL) SWIG_fail;
42809 temp3 = true;
42810 }
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 resultobj = SWIG_From_int(static_cast< int >(result));
42818 {
42819 if (temp2)
42820 delete arg2;
42821 }
42822 {
42823 if (temp3)
42824 delete arg3;
42825 }
42826 return resultobj;
42827 fail:
42828 {
42829 if (temp2)
42830 delete arg2;
42831 }
42832 {
42833 if (temp3)
42834 delete arg3;
42835 }
42836 return NULL;
42837 }
42838
42839
42840 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42841 PyObject *resultobj = 0;
42842 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42843 int arg2 ;
42844 wxMenuItem *result = 0 ;
42845 void *argp1 = 0 ;
42846 int res1 = 0 ;
42847 int val2 ;
42848 int ecode2 = 0 ;
42849 PyObject * obj0 = 0 ;
42850 PyObject * obj1 = 0 ;
42851 char * kwnames[] = {
42852 (char *) "self",(char *) "id", NULL
42853 };
42854
42855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42857 if (!SWIG_IsOK(res1)) {
42858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42859 }
42860 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42861 ecode2 = SWIG_AsVal_int(obj1, &val2);
42862 if (!SWIG_IsOK(ecode2)) {
42863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42864 }
42865 arg2 = static_cast< int >(val2);
42866 {
42867 PyThreadState* __tstate = wxPyBeginAllowThreads();
42868 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42869 wxPyEndAllowThreads(__tstate);
42870 if (PyErr_Occurred()) SWIG_fail;
42871 }
42872 {
42873 resultobj = wxPyMake_wxObject(result, (bool)0);
42874 }
42875 return resultobj;
42876 fail:
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj = 0;
42883 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42884 wxString *arg2 = 0 ;
42885 int result;
42886 void *argp1 = 0 ;
42887 int res1 = 0 ;
42888 bool temp2 = false ;
42889 PyObject * obj0 = 0 ;
42890 PyObject * obj1 = 0 ;
42891 char * kwnames[] = {
42892 (char *) "self",(char *) "title", NULL
42893 };
42894
42895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42897 if (!SWIG_IsOK(res1)) {
42898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42899 }
42900 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42901 {
42902 arg2 = wxString_in_helper(obj1);
42903 if (arg2 == NULL) SWIG_fail;
42904 temp2 = true;
42905 }
42906 {
42907 PyThreadState* __tstate = wxPyBeginAllowThreads();
42908 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 resultobj = SWIG_From_int(static_cast< int >(result));
42913 {
42914 if (temp2)
42915 delete arg2;
42916 }
42917 return resultobj;
42918 fail:
42919 {
42920 if (temp2)
42921 delete arg2;
42922 }
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42930 int arg2 ;
42931 bool arg3 ;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 int val2 ;
42935 int ecode2 = 0 ;
42936 bool val3 ;
42937 int ecode3 = 0 ;
42938 PyObject * obj0 = 0 ;
42939 PyObject * obj1 = 0 ;
42940 PyObject * obj2 = 0 ;
42941 char * kwnames[] = {
42942 (char *) "self",(char *) "id",(char *) "enable", NULL
42943 };
42944
42945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42947 if (!SWIG_IsOK(res1)) {
42948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42949 }
42950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42951 ecode2 = SWIG_AsVal_int(obj1, &val2);
42952 if (!SWIG_IsOK(ecode2)) {
42953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42954 }
42955 arg2 = static_cast< int >(val2);
42956 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42957 if (!SWIG_IsOK(ecode3)) {
42958 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42959 }
42960 arg3 = static_cast< bool >(val3);
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 (arg1)->Enable(arg2,arg3);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_Py_Void();
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = 0;
42976 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42977 int arg2 ;
42978 bool arg3 ;
42979 void *argp1 = 0 ;
42980 int res1 = 0 ;
42981 int val2 ;
42982 int ecode2 = 0 ;
42983 bool val3 ;
42984 int ecode3 = 0 ;
42985 PyObject * obj0 = 0 ;
42986 PyObject * obj1 = 0 ;
42987 PyObject * obj2 = 0 ;
42988 char * kwnames[] = {
42989 (char *) "self",(char *) "id",(char *) "check", NULL
42990 };
42991
42992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42994 if (!SWIG_IsOK(res1)) {
42995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42996 }
42997 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42998 ecode2 = SWIG_AsVal_int(obj1, &val2);
42999 if (!SWIG_IsOK(ecode2)) {
43000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
43001 }
43002 arg2 = static_cast< int >(val2);
43003 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43004 if (!SWIG_IsOK(ecode3)) {
43005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
43006 }
43007 arg3 = static_cast< bool >(val3);
43008 {
43009 PyThreadState* __tstate = wxPyBeginAllowThreads();
43010 (arg1)->Check(arg2,arg3);
43011 wxPyEndAllowThreads(__tstate);
43012 if (PyErr_Occurred()) SWIG_fail;
43013 }
43014 resultobj = SWIG_Py_Void();
43015 return resultobj;
43016 fail:
43017 return NULL;
43018 }
43019
43020
43021 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43022 PyObject *resultobj = 0;
43023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43024 int arg2 ;
43025 bool result;
43026 void *argp1 = 0 ;
43027 int res1 = 0 ;
43028 int val2 ;
43029 int ecode2 = 0 ;
43030 PyObject * obj0 = 0 ;
43031 PyObject * obj1 = 0 ;
43032 char * kwnames[] = {
43033 (char *) "self",(char *) "id", NULL
43034 };
43035
43036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43038 if (!SWIG_IsOK(res1)) {
43039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43040 }
43041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43042 ecode2 = SWIG_AsVal_int(obj1, &val2);
43043 if (!SWIG_IsOK(ecode2)) {
43044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
43045 }
43046 arg2 = static_cast< int >(val2);
43047 {
43048 PyThreadState* __tstate = wxPyBeginAllowThreads();
43049 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
43050 wxPyEndAllowThreads(__tstate);
43051 if (PyErr_Occurred()) SWIG_fail;
43052 }
43053 {
43054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43055 }
43056 return resultobj;
43057 fail:
43058 return NULL;
43059 }
43060
43061
43062 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43063 PyObject *resultobj = 0;
43064 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43065 int arg2 ;
43066 bool result;
43067 void *argp1 = 0 ;
43068 int res1 = 0 ;
43069 int val2 ;
43070 int ecode2 = 0 ;
43071 PyObject * obj0 = 0 ;
43072 PyObject * obj1 = 0 ;
43073 char * kwnames[] = {
43074 (char *) "self",(char *) "id", NULL
43075 };
43076
43077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43079 if (!SWIG_IsOK(res1)) {
43080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43081 }
43082 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43083 ecode2 = SWIG_AsVal_int(obj1, &val2);
43084 if (!SWIG_IsOK(ecode2)) {
43085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43086 }
43087 arg2 = static_cast< int >(val2);
43088 {
43089 PyThreadState* __tstate = wxPyBeginAllowThreads();
43090 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
43091 wxPyEndAllowThreads(__tstate);
43092 if (PyErr_Occurred()) SWIG_fail;
43093 }
43094 {
43095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43096 }
43097 return resultobj;
43098 fail:
43099 return NULL;
43100 }
43101
43102
43103 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43104 PyObject *resultobj = 0;
43105 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43106 int arg2 ;
43107 wxString *arg3 = 0 ;
43108 void *argp1 = 0 ;
43109 int res1 = 0 ;
43110 int val2 ;
43111 int ecode2 = 0 ;
43112 bool temp3 = false ;
43113 PyObject * obj0 = 0 ;
43114 PyObject * obj1 = 0 ;
43115 PyObject * obj2 = 0 ;
43116 char * kwnames[] = {
43117 (char *) "self",(char *) "id",(char *) "label", NULL
43118 };
43119
43120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43126 ecode2 = SWIG_AsVal_int(obj1, &val2);
43127 if (!SWIG_IsOK(ecode2)) {
43128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
43129 }
43130 arg2 = static_cast< int >(val2);
43131 {
43132 arg3 = wxString_in_helper(obj2);
43133 if (arg3 == NULL) SWIG_fail;
43134 temp3 = true;
43135 }
43136 {
43137 PyThreadState* __tstate = wxPyBeginAllowThreads();
43138 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43139 wxPyEndAllowThreads(__tstate);
43140 if (PyErr_Occurred()) SWIG_fail;
43141 }
43142 resultobj = SWIG_Py_Void();
43143 {
43144 if (temp3)
43145 delete arg3;
43146 }
43147 return resultobj;
43148 fail:
43149 {
43150 if (temp3)
43151 delete arg3;
43152 }
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43160 int arg2 ;
43161 wxString result;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 int val2 ;
43165 int ecode2 = 0 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char * kwnames[] = {
43169 (char *) "self",(char *) "id", NULL
43170 };
43171
43172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43178 ecode2 = SWIG_AsVal_int(obj1, &val2);
43179 if (!SWIG_IsOK(ecode2)) {
43180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
43181 }
43182 arg2 = static_cast< int >(val2);
43183 {
43184 PyThreadState* __tstate = wxPyBeginAllowThreads();
43185 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
43186 wxPyEndAllowThreads(__tstate);
43187 if (PyErr_Occurred()) SWIG_fail;
43188 }
43189 {
43190 #if wxUSE_UNICODE
43191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43192 #else
43193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43194 #endif
43195 }
43196 return resultobj;
43197 fail:
43198 return NULL;
43199 }
43200
43201
43202 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43203 PyObject *resultobj = 0;
43204 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43205 int arg2 ;
43206 wxString *arg3 = 0 ;
43207 void *argp1 = 0 ;
43208 int res1 = 0 ;
43209 int val2 ;
43210 int ecode2 = 0 ;
43211 bool temp3 = false ;
43212 PyObject * obj0 = 0 ;
43213 PyObject * obj1 = 0 ;
43214 PyObject * obj2 = 0 ;
43215 char * kwnames[] = {
43216 (char *) "self",(char *) "id",(char *) "helpString", NULL
43217 };
43218
43219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43221 if (!SWIG_IsOK(res1)) {
43222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43223 }
43224 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43225 ecode2 = SWIG_AsVal_int(obj1, &val2);
43226 if (!SWIG_IsOK(ecode2)) {
43227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43228 }
43229 arg2 = static_cast< int >(val2);
43230 {
43231 arg3 = wxString_in_helper(obj2);
43232 if (arg3 == NULL) SWIG_fail;
43233 temp3 = true;
43234 }
43235 {
43236 PyThreadState* __tstate = wxPyBeginAllowThreads();
43237 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43238 wxPyEndAllowThreads(__tstate);
43239 if (PyErr_Occurred()) SWIG_fail;
43240 }
43241 resultobj = SWIG_Py_Void();
43242 {
43243 if (temp3)
43244 delete arg3;
43245 }
43246 return resultobj;
43247 fail:
43248 {
43249 if (temp3)
43250 delete arg3;
43251 }
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43257 PyObject *resultobj = 0;
43258 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43259 int arg2 ;
43260 wxString result;
43261 void *argp1 = 0 ;
43262 int res1 = 0 ;
43263 int val2 ;
43264 int ecode2 = 0 ;
43265 PyObject * obj0 = 0 ;
43266 PyObject * obj1 = 0 ;
43267 char * kwnames[] = {
43268 (char *) "self",(char *) "id", NULL
43269 };
43270
43271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43273 if (!SWIG_IsOK(res1)) {
43274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43275 }
43276 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43277 ecode2 = SWIG_AsVal_int(obj1, &val2);
43278 if (!SWIG_IsOK(ecode2)) {
43279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43280 }
43281 arg2 = static_cast< int >(val2);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 #if wxUSE_UNICODE
43290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43291 #else
43292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43293 #endif
43294 }
43295 return resultobj;
43296 fail:
43297 return NULL;
43298 }
43299
43300
43301 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43302 PyObject *resultobj = 0;
43303 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43304 wxFrame *result = 0 ;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 PyObject *swig_obj[1] ;
43308
43309 if (!args) SWIG_fail;
43310 swig_obj[0] = args;
43311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43312 if (!SWIG_IsOK(res1)) {
43313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43314 }
43315 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 {
43323 resultobj = wxPyMake_wxObject(result, (bool)0);
43324 }
43325 return resultobj;
43326 fail:
43327 return NULL;
43328 }
43329
43330
43331 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43332 PyObject *resultobj = 0;
43333 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43334 bool result;
43335 void *argp1 = 0 ;
43336 int res1 = 0 ;
43337 PyObject *swig_obj[1] ;
43338
43339 if (!args) SWIG_fail;
43340 swig_obj[0] = args;
43341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43342 if (!SWIG_IsOK(res1)) {
43343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
43344 }
43345 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 {
43353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43354 }
43355 return resultobj;
43356 fail:
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43362 PyObject *resultobj = 0;
43363 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43364 wxFrame *arg2 = (wxFrame *) 0 ;
43365 void *argp1 = 0 ;
43366 int res1 = 0 ;
43367 void *argp2 = 0 ;
43368 int res2 = 0 ;
43369 PyObject * obj0 = 0 ;
43370 PyObject * obj1 = 0 ;
43371 char * kwnames[] = {
43372 (char *) "self",(char *) "frame", NULL
43373 };
43374
43375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
43376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43377 if (!SWIG_IsOK(res1)) {
43378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43379 }
43380 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
43382 if (!SWIG_IsOK(res2)) {
43383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
43384 }
43385 arg2 = reinterpret_cast< wxFrame * >(argp2);
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 (arg1)->Attach(arg2);
43389 wxPyEndAllowThreads(__tstate);
43390 if (PyErr_Occurred()) SWIG_fail;
43391 }
43392 resultobj = SWIG_Py_Void();
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43400 PyObject *resultobj = 0;
43401 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43402 void *argp1 = 0 ;
43403 int res1 = 0 ;
43404 PyObject *swig_obj[1] ;
43405
43406 if (!args) SWIG_fail;
43407 swig_obj[0] = args;
43408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43409 if (!SWIG_IsOK(res1)) {
43410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43411 }
43412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43413 {
43414 PyThreadState* __tstate = wxPyBeginAllowThreads();
43415 (arg1)->Detach();
43416 wxPyEndAllowThreads(__tstate);
43417 if (PyErr_Occurred()) SWIG_fail;
43418 }
43419 resultobj = SWIG_Py_Void();
43420 return resultobj;
43421 fail:
43422 return NULL;
43423 }
43424
43425
43426 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43427 PyObject *resultobj = 0;
43428 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
43429 void *argp1 = 0 ;
43430 int res1 = 0 ;
43431 PyObject *swig_obj[1] ;
43432
43433 if (!args) SWIG_fail;
43434 swig_obj[0] = args;
43435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
43436 if (!SWIG_IsOK(res1)) {
43437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
43438 }
43439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
43440 {
43441 PyThreadState* __tstate = wxPyBeginAllowThreads();
43442 (arg1)->UpdateMenus();
43443 wxPyEndAllowThreads(__tstate);
43444 if (PyErr_Occurred()) SWIG_fail;
43445 }
43446 resultobj = SWIG_Py_Void();
43447 return resultobj;
43448 fail:
43449 return NULL;
43450 }
43451
43452
43453 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43454 PyObject *resultobj = 0;
43455 bool arg1 ;
43456 bool val1 ;
43457 int ecode1 = 0 ;
43458 PyObject * obj0 = 0 ;
43459 char * kwnames[] = {
43460 (char *) "enable", NULL
43461 };
43462
43463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
43464 ecode1 = SWIG_AsVal_bool(obj0, &val1);
43465 if (!SWIG_IsOK(ecode1)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
43467 }
43468 arg1 = static_cast< bool >(val1);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 wxMenuBar_SetAutoWindowMenu(arg1);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 resultobj = SWIG_Py_Void();
43476 return resultobj;
43477 fail:
43478 return NULL;
43479 }
43480
43481
43482 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43483 PyObject *resultobj = 0;
43484 bool result;
43485
43486 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
43487 {
43488 PyThreadState* __tstate = wxPyBeginAllowThreads();
43489 result = (bool)wxMenuBar_GetAutoWindowMenu();
43490 wxPyEndAllowThreads(__tstate);
43491 if (PyErr_Occurred()) SWIG_fail;
43492 }
43493 {
43494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43495 }
43496 return resultobj;
43497 fail:
43498 return NULL;
43499 }
43500
43501
43502 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43503 PyObject *obj;
43504 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43505 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43506 return SWIG_Py_Void();
43507 }
43508
43509 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43510 return SWIG_Python_InitShadowInstance(args);
43511 }
43512
43513 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43514 PyObject *resultobj = 0;
43515 wxMenu *arg1 = (wxMenu *) NULL ;
43516 int arg2 = (int) wxID_ANY ;
43517 wxString const &arg3_defvalue = wxPyEmptyString ;
43518 wxString *arg3 = (wxString *) &arg3_defvalue ;
43519 wxString const &arg4_defvalue = wxPyEmptyString ;
43520 wxString *arg4 = (wxString *) &arg4_defvalue ;
43521 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43522 wxMenu *arg6 = (wxMenu *) NULL ;
43523 wxMenuItem *result = 0 ;
43524 void *argp1 = 0 ;
43525 int res1 = 0 ;
43526 int val2 ;
43527 int ecode2 = 0 ;
43528 bool temp3 = false ;
43529 bool temp4 = false ;
43530 int val5 ;
43531 int ecode5 = 0 ;
43532 void *argp6 = 0 ;
43533 int res6 = 0 ;
43534 PyObject * obj0 = 0 ;
43535 PyObject * obj1 = 0 ;
43536 PyObject * obj2 = 0 ;
43537 PyObject * obj3 = 0 ;
43538 PyObject * obj4 = 0 ;
43539 PyObject * obj5 = 0 ;
43540 char * kwnames[] = {
43541 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43542 };
43543
43544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43545 if (obj0) {
43546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43547 if (!SWIG_IsOK(res1)) {
43548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43549 }
43550 arg1 = reinterpret_cast< wxMenu * >(argp1);
43551 }
43552 if (obj1) {
43553 ecode2 = SWIG_AsVal_int(obj1, &val2);
43554 if (!SWIG_IsOK(ecode2)) {
43555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43556 }
43557 arg2 = static_cast< int >(val2);
43558 }
43559 if (obj2) {
43560 {
43561 arg3 = wxString_in_helper(obj2);
43562 if (arg3 == NULL) SWIG_fail;
43563 temp3 = true;
43564 }
43565 }
43566 if (obj3) {
43567 {
43568 arg4 = wxString_in_helper(obj3);
43569 if (arg4 == NULL) SWIG_fail;
43570 temp4 = true;
43571 }
43572 }
43573 if (obj4) {
43574 ecode5 = SWIG_AsVal_int(obj4, &val5);
43575 if (!SWIG_IsOK(ecode5)) {
43576 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43577 }
43578 arg5 = static_cast< wxItemKind >(val5);
43579 }
43580 if (obj5) {
43581 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43582 if (!SWIG_IsOK(res6)) {
43583 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43584 }
43585 arg6 = reinterpret_cast< wxMenu * >(argp6);
43586 }
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43590 wxPyEndAllowThreads(__tstate);
43591 if (PyErr_Occurred()) SWIG_fail;
43592 }
43593 {
43594 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43595 }
43596 {
43597 if (temp3)
43598 delete arg3;
43599 }
43600 {
43601 if (temp4)
43602 delete arg4;
43603 }
43604 return resultobj;
43605 fail:
43606 {
43607 if (temp3)
43608 delete arg3;
43609 }
43610 {
43611 if (temp4)
43612 delete arg4;
43613 }
43614 return NULL;
43615 }
43616
43617
43618 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43619 PyObject *resultobj = 0;
43620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43621 void *argp1 = 0 ;
43622 int res1 = 0 ;
43623 PyObject *swig_obj[1] ;
43624
43625 if (!args) SWIG_fail;
43626 swig_obj[0] = args;
43627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43628 if (!SWIG_IsOK(res1)) {
43629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43630 }
43631 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43632 {
43633 PyThreadState* __tstate = wxPyBeginAllowThreads();
43634 delete arg1;
43635
43636 wxPyEndAllowThreads(__tstate);
43637 if (PyErr_Occurred()) SWIG_fail;
43638 }
43639 resultobj = SWIG_Py_Void();
43640 return resultobj;
43641 fail:
43642 return NULL;
43643 }
43644
43645
43646 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43647 PyObject *resultobj = 0;
43648 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43649 wxMenu *result = 0 ;
43650 void *argp1 = 0 ;
43651 int res1 = 0 ;
43652 PyObject *swig_obj[1] ;
43653
43654 if (!args) SWIG_fail;
43655 swig_obj[0] = args;
43656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43659 }
43660 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43661 {
43662 PyThreadState* __tstate = wxPyBeginAllowThreads();
43663 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = wxPyMake_wxObject(result, 0);
43669 }
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43677 PyObject *resultobj = 0;
43678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43679 wxMenu *arg2 = (wxMenu *) 0 ;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 void *argp2 = 0 ;
43683 int res2 = 0 ;
43684 PyObject * obj0 = 0 ;
43685 PyObject * obj1 = 0 ;
43686 char * kwnames[] = {
43687 (char *) "self",(char *) "menu", NULL
43688 };
43689
43690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43692 if (!SWIG_IsOK(res1)) {
43693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43694 }
43695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43697 if (!SWIG_IsOK(res2)) {
43698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43699 }
43700 arg2 = reinterpret_cast< wxMenu * >(argp2);
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 (arg1)->SetMenu(arg2);
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 resultobj = SWIG_Py_Void();
43708 return resultobj;
43709 fail:
43710 return NULL;
43711 }
43712
43713
43714 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43715 PyObject *resultobj = 0;
43716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43717 int arg2 ;
43718 void *argp1 = 0 ;
43719 int res1 = 0 ;
43720 int val2 ;
43721 int ecode2 = 0 ;
43722 PyObject * obj0 = 0 ;
43723 PyObject * obj1 = 0 ;
43724 char * kwnames[] = {
43725 (char *) "self",(char *) "id", NULL
43726 };
43727
43728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43734 ecode2 = SWIG_AsVal_int(obj1, &val2);
43735 if (!SWIG_IsOK(ecode2)) {
43736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43737 }
43738 arg2 = static_cast< int >(val2);
43739 {
43740 PyThreadState* __tstate = wxPyBeginAllowThreads();
43741 (arg1)->SetId(arg2);
43742 wxPyEndAllowThreads(__tstate);
43743 if (PyErr_Occurred()) SWIG_fail;
43744 }
43745 resultobj = SWIG_Py_Void();
43746 return resultobj;
43747 fail:
43748 return NULL;
43749 }
43750
43751
43752 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43753 PyObject *resultobj = 0;
43754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43755 int result;
43756 void *argp1 = 0 ;
43757 int res1 = 0 ;
43758 PyObject *swig_obj[1] ;
43759
43760 if (!args) SWIG_fail;
43761 swig_obj[0] = args;
43762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43763 if (!SWIG_IsOK(res1)) {
43764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43765 }
43766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 result = (int)((wxMenuItem const *)arg1)->GetId();
43770 wxPyEndAllowThreads(__tstate);
43771 if (PyErr_Occurred()) SWIG_fail;
43772 }
43773 resultobj = SWIG_From_int(static_cast< int >(result));
43774 return resultobj;
43775 fail:
43776 return NULL;
43777 }
43778
43779
43780 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43781 PyObject *resultobj = 0;
43782 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43783 bool result;
43784 void *argp1 = 0 ;
43785 int res1 = 0 ;
43786 PyObject *swig_obj[1] ;
43787
43788 if (!args) SWIG_fail;
43789 swig_obj[0] = args;
43790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43791 if (!SWIG_IsOK(res1)) {
43792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43793 }
43794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43795 {
43796 PyThreadState* __tstate = wxPyBeginAllowThreads();
43797 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43798 wxPyEndAllowThreads(__tstate);
43799 if (PyErr_Occurred()) SWIG_fail;
43800 }
43801 {
43802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43803 }
43804 return resultobj;
43805 fail:
43806 return NULL;
43807 }
43808
43809
43810 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43811 PyObject *resultobj = 0;
43812 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43813 wxString *arg2 = 0 ;
43814 void *argp1 = 0 ;
43815 int res1 = 0 ;
43816 bool temp2 = false ;
43817 PyObject * obj0 = 0 ;
43818 PyObject * obj1 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "str", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43827 }
43828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43829 {
43830 arg2 = wxString_in_helper(obj1);
43831 if (arg2 == NULL) SWIG_fail;
43832 temp2 = true;
43833 }
43834 {
43835 PyThreadState* __tstate = wxPyBeginAllowThreads();
43836 (arg1)->SetText((wxString const &)*arg2);
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 resultobj = SWIG_Py_Void();
43841 {
43842 if (temp2)
43843 delete arg2;
43844 }
43845 return resultobj;
43846 fail:
43847 {
43848 if (temp2)
43849 delete arg2;
43850 }
43851 return NULL;
43852 }
43853
43854
43855 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43856 PyObject *resultobj = 0;
43857 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43858 wxString result;
43859 void *argp1 = 0 ;
43860 int res1 = 0 ;
43861 PyObject *swig_obj[1] ;
43862
43863 if (!args) SWIG_fail;
43864 swig_obj[0] = args;
43865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43866 if (!SWIG_IsOK(res1)) {
43867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43868 }
43869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43870 {
43871 PyThreadState* __tstate = wxPyBeginAllowThreads();
43872 result = ((wxMenuItem const *)arg1)->GetLabel();
43873 wxPyEndAllowThreads(__tstate);
43874 if (PyErr_Occurred()) SWIG_fail;
43875 }
43876 {
43877 #if wxUSE_UNICODE
43878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43879 #else
43880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43881 #endif
43882 }
43883 return resultobj;
43884 fail:
43885 return NULL;
43886 }
43887
43888
43889 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43890 PyObject *resultobj = 0;
43891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43892 wxString *result = 0 ;
43893 void *argp1 = 0 ;
43894 int res1 = 0 ;
43895 PyObject *swig_obj[1] ;
43896
43897 if (!args) SWIG_fail;
43898 swig_obj[0] = args;
43899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43900 if (!SWIG_IsOK(res1)) {
43901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43902 }
43903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43904 {
43905 PyThreadState* __tstate = wxPyBeginAllowThreads();
43906 {
43907 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43908 result = (wxString *) &_result_ref;
43909 }
43910 wxPyEndAllowThreads(__tstate);
43911 if (PyErr_Occurred()) SWIG_fail;
43912 }
43913 {
43914 #if wxUSE_UNICODE
43915 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43916 #else
43917 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43918 #endif
43919 }
43920 return resultobj;
43921 fail:
43922 return NULL;
43923 }
43924
43925
43926 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43927 PyObject *resultobj = 0;
43928 wxString *arg1 = 0 ;
43929 wxString result;
43930 bool temp1 = false ;
43931 PyObject * obj0 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "text", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43937 {
43938 arg1 = wxString_in_helper(obj0);
43939 if (arg1 == NULL) SWIG_fail;
43940 temp1 = true;
43941 }
43942 {
43943 PyThreadState* __tstate = wxPyBeginAllowThreads();
43944 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43945 wxPyEndAllowThreads(__tstate);
43946 if (PyErr_Occurred()) SWIG_fail;
43947 }
43948 {
43949 #if wxUSE_UNICODE
43950 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43951 #else
43952 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43953 #endif
43954 }
43955 {
43956 if (temp1)
43957 delete arg1;
43958 }
43959 return resultobj;
43960 fail:
43961 {
43962 if (temp1)
43963 delete arg1;
43964 }
43965 return NULL;
43966 }
43967
43968
43969 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43970 PyObject *resultobj = 0;
43971 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43972 wxItemKind result;
43973 void *argp1 = 0 ;
43974 int res1 = 0 ;
43975 PyObject *swig_obj[1] ;
43976
43977 if (!args) SWIG_fail;
43978 swig_obj[0] = args;
43979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43980 if (!SWIG_IsOK(res1)) {
43981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43982 }
43983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43984 {
43985 PyThreadState* __tstate = wxPyBeginAllowThreads();
43986 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43987 wxPyEndAllowThreads(__tstate);
43988 if (PyErr_Occurred()) SWIG_fail;
43989 }
43990 resultobj = SWIG_From_int(static_cast< int >(result));
43991 return resultobj;
43992 fail:
43993 return NULL;
43994 }
43995
43996
43997 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43998 PyObject *resultobj = 0;
43999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44000 wxItemKind arg2 ;
44001 void *argp1 = 0 ;
44002 int res1 = 0 ;
44003 int val2 ;
44004 int ecode2 = 0 ;
44005 PyObject * obj0 = 0 ;
44006 PyObject * obj1 = 0 ;
44007 char * kwnames[] = {
44008 (char *) "self",(char *) "kind", NULL
44009 };
44010
44011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
44012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44013 if (!SWIG_IsOK(res1)) {
44014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44015 }
44016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44017 ecode2 = SWIG_AsVal_int(obj1, &val2);
44018 if (!SWIG_IsOK(ecode2)) {
44019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
44020 }
44021 arg2 = static_cast< wxItemKind >(val2);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 (arg1)->SetKind(arg2);
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_Py_Void();
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44036 PyObject *resultobj = 0;
44037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44038 bool arg2 ;
44039 void *argp1 = 0 ;
44040 int res1 = 0 ;
44041 bool val2 ;
44042 int ecode2 = 0 ;
44043 PyObject * obj0 = 0 ;
44044 PyObject * obj1 = 0 ;
44045 char * kwnames[] = {
44046 (char *) "self",(char *) "checkable", NULL
44047 };
44048
44049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
44050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44053 }
44054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44056 if (!SWIG_IsOK(ecode2)) {
44057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
44058 }
44059 arg2 = static_cast< bool >(val2);
44060 {
44061 PyThreadState* __tstate = wxPyBeginAllowThreads();
44062 (arg1)->SetCheckable(arg2);
44063 wxPyEndAllowThreads(__tstate);
44064 if (PyErr_Occurred()) SWIG_fail;
44065 }
44066 resultobj = SWIG_Py_Void();
44067 return resultobj;
44068 fail:
44069 return NULL;
44070 }
44071
44072
44073 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44074 PyObject *resultobj = 0;
44075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44076 bool result;
44077 void *argp1 = 0 ;
44078 int res1 = 0 ;
44079 PyObject *swig_obj[1] ;
44080
44081 if (!args) SWIG_fail;
44082 swig_obj[0] = args;
44083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44084 if (!SWIG_IsOK(res1)) {
44085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44086 }
44087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44088 {
44089 PyThreadState* __tstate = wxPyBeginAllowThreads();
44090 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 {
44095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44096 }
44097 return resultobj;
44098 fail:
44099 return NULL;
44100 }
44101
44102
44103 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44104 PyObject *resultobj = 0;
44105 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44106 bool result;
44107 void *argp1 = 0 ;
44108 int res1 = 0 ;
44109 PyObject *swig_obj[1] ;
44110
44111 if (!args) SWIG_fail;
44112 swig_obj[0] = args;
44113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44114 if (!SWIG_IsOK(res1)) {
44115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44116 }
44117 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44118 {
44119 PyThreadState* __tstate = wxPyBeginAllowThreads();
44120 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
44121 wxPyEndAllowThreads(__tstate);
44122 if (PyErr_Occurred()) SWIG_fail;
44123 }
44124 {
44125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44126 }
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44134 PyObject *resultobj = 0;
44135 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44136 wxMenu *arg2 = (wxMenu *) 0 ;
44137 void *argp1 = 0 ;
44138 int res1 = 0 ;
44139 void *argp2 = 0 ;
44140 int res2 = 0 ;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143 char * kwnames[] = {
44144 (char *) "self",(char *) "menu", NULL
44145 };
44146
44147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44149 if (!SWIG_IsOK(res1)) {
44150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44151 }
44152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44154 if (!SWIG_IsOK(res2)) {
44155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
44156 }
44157 arg2 = reinterpret_cast< wxMenu * >(argp2);
44158 {
44159 PyThreadState* __tstate = wxPyBeginAllowThreads();
44160 (arg1)->SetSubMenu(arg2);
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 resultobj = SWIG_Py_Void();
44165 return resultobj;
44166 fail:
44167 return NULL;
44168 }
44169
44170
44171 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44172 PyObject *resultobj = 0;
44173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44174 wxMenu *result = 0 ;
44175 void *argp1 = 0 ;
44176 int res1 = 0 ;
44177 PyObject *swig_obj[1] ;
44178
44179 if (!args) SWIG_fail;
44180 swig_obj[0] = args;
44181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44182 if (!SWIG_IsOK(res1)) {
44183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44184 }
44185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44186 {
44187 PyThreadState* __tstate = wxPyBeginAllowThreads();
44188 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 {
44193 resultobj = wxPyMake_wxObject(result, 0);
44194 }
44195 return resultobj;
44196 fail:
44197 return NULL;
44198 }
44199
44200
44201 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44202 PyObject *resultobj = 0;
44203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44204 bool arg2 = (bool) true ;
44205 void *argp1 = 0 ;
44206 int res1 = 0 ;
44207 bool val2 ;
44208 int ecode2 = 0 ;
44209 PyObject * obj0 = 0 ;
44210 PyObject * obj1 = 0 ;
44211 char * kwnames[] = {
44212 (char *) "self",(char *) "enable", NULL
44213 };
44214
44215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
44216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44221 if (obj1) {
44222 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44223 if (!SWIG_IsOK(ecode2)) {
44224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
44225 }
44226 arg2 = static_cast< bool >(val2);
44227 }
44228 {
44229 PyThreadState* __tstate = wxPyBeginAllowThreads();
44230 (arg1)->Enable(arg2);
44231 wxPyEndAllowThreads(__tstate);
44232 if (PyErr_Occurred()) SWIG_fail;
44233 }
44234 resultobj = SWIG_Py_Void();
44235 return resultobj;
44236 fail:
44237 return NULL;
44238 }
44239
44240
44241 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44242 PyObject *resultobj = 0;
44243 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44244 bool result;
44245 void *argp1 = 0 ;
44246 int res1 = 0 ;
44247 PyObject *swig_obj[1] ;
44248
44249 if (!args) SWIG_fail;
44250 swig_obj[0] = args;
44251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44252 if (!SWIG_IsOK(res1)) {
44253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44254 }
44255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44256 {
44257 PyThreadState* __tstate = wxPyBeginAllowThreads();
44258 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
44259 wxPyEndAllowThreads(__tstate);
44260 if (PyErr_Occurred()) SWIG_fail;
44261 }
44262 {
44263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44264 }
44265 return resultobj;
44266 fail:
44267 return NULL;
44268 }
44269
44270
44271 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44272 PyObject *resultobj = 0;
44273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44274 bool arg2 = (bool) true ;
44275 void *argp1 = 0 ;
44276 int res1 = 0 ;
44277 bool val2 ;
44278 int ecode2 = 0 ;
44279 PyObject * obj0 = 0 ;
44280 PyObject * obj1 = 0 ;
44281 char * kwnames[] = {
44282 (char *) "self",(char *) "check", NULL
44283 };
44284
44285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
44286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44287 if (!SWIG_IsOK(res1)) {
44288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44289 }
44290 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44291 if (obj1) {
44292 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44293 if (!SWIG_IsOK(ecode2)) {
44294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
44295 }
44296 arg2 = static_cast< bool >(val2);
44297 }
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 (arg1)->Check(arg2);
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 resultobj = SWIG_Py_Void();
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44312 PyObject *resultobj = 0;
44313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44314 bool result;
44315 void *argp1 = 0 ;
44316 int res1 = 0 ;
44317 PyObject *swig_obj[1] ;
44318
44319 if (!args) SWIG_fail;
44320 swig_obj[0] = args;
44321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44322 if (!SWIG_IsOK(res1)) {
44323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44324 }
44325 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44326 {
44327 PyThreadState* __tstate = wxPyBeginAllowThreads();
44328 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
44329 wxPyEndAllowThreads(__tstate);
44330 if (PyErr_Occurred()) SWIG_fail;
44331 }
44332 {
44333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44334 }
44335 return resultobj;
44336 fail:
44337 return NULL;
44338 }
44339
44340
44341 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44342 PyObject *resultobj = 0;
44343 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44344 void *argp1 = 0 ;
44345 int res1 = 0 ;
44346 PyObject *swig_obj[1] ;
44347
44348 if (!args) SWIG_fail;
44349 swig_obj[0] = args;
44350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44353 }
44354 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 (arg1)->Toggle();
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_Py_Void();
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44369 PyObject *resultobj = 0;
44370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44371 wxString *arg2 = 0 ;
44372 void *argp1 = 0 ;
44373 int res1 = 0 ;
44374 bool temp2 = false ;
44375 PyObject * obj0 = 0 ;
44376 PyObject * obj1 = 0 ;
44377 char * kwnames[] = {
44378 (char *) "self",(char *) "str", NULL
44379 };
44380
44381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
44382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44383 if (!SWIG_IsOK(res1)) {
44384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44385 }
44386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44387 {
44388 arg2 = wxString_in_helper(obj1);
44389 if (arg2 == NULL) SWIG_fail;
44390 temp2 = true;
44391 }
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 (arg1)->SetHelp((wxString const &)*arg2);
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 resultobj = SWIG_Py_Void();
44399 {
44400 if (temp2)
44401 delete arg2;
44402 }
44403 return resultobj;
44404 fail:
44405 {
44406 if (temp2)
44407 delete arg2;
44408 }
44409 return NULL;
44410 }
44411
44412
44413 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44414 PyObject *resultobj = 0;
44415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44416 wxString *result = 0 ;
44417 void *argp1 = 0 ;
44418 int res1 = 0 ;
44419 PyObject *swig_obj[1] ;
44420
44421 if (!args) SWIG_fail;
44422 swig_obj[0] = args;
44423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44424 if (!SWIG_IsOK(res1)) {
44425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44426 }
44427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44428 {
44429 PyThreadState* __tstate = wxPyBeginAllowThreads();
44430 {
44431 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
44432 result = (wxString *) &_result_ref;
44433 }
44434 wxPyEndAllowThreads(__tstate);
44435 if (PyErr_Occurred()) SWIG_fail;
44436 }
44437 {
44438 #if wxUSE_UNICODE
44439 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
44440 #else
44441 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
44442 #endif
44443 }
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44451 PyObject *resultobj = 0;
44452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44453 wxAcceleratorEntry *result = 0 ;
44454 void *argp1 = 0 ;
44455 int res1 = 0 ;
44456 PyObject *swig_obj[1] ;
44457
44458 if (!args) SWIG_fail;
44459 swig_obj[0] = args;
44460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44461 if (!SWIG_IsOK(res1)) {
44462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44463 }
44464 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44465 {
44466 PyThreadState* __tstate = wxPyBeginAllowThreads();
44467 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
44468 wxPyEndAllowThreads(__tstate);
44469 if (PyErr_Occurred()) SWIG_fail;
44470 }
44471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44472 return resultobj;
44473 fail:
44474 return NULL;
44475 }
44476
44477
44478 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44479 PyObject *resultobj = 0;
44480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44481 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
44482 void *argp1 = 0 ;
44483 int res1 = 0 ;
44484 void *argp2 = 0 ;
44485 int res2 = 0 ;
44486 PyObject * obj0 = 0 ;
44487 PyObject * obj1 = 0 ;
44488 char * kwnames[] = {
44489 (char *) "self",(char *) "accel", NULL
44490 };
44491
44492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44494 if (!SWIG_IsOK(res1)) {
44495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44496 }
44497 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44499 if (!SWIG_IsOK(res2)) {
44500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44501 }
44502 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44503 {
44504 PyThreadState* __tstate = wxPyBeginAllowThreads();
44505 (arg1)->SetAccel(arg2);
44506 wxPyEndAllowThreads(__tstate);
44507 if (PyErr_Occurred()) SWIG_fail;
44508 }
44509 resultobj = SWIG_Py_Void();
44510 return resultobj;
44511 fail:
44512 return NULL;
44513 }
44514
44515
44516 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj = 0;
44518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44519 wxBitmap *arg2 = 0 ;
44520 void *argp1 = 0 ;
44521 int res1 = 0 ;
44522 void *argp2 = 0 ;
44523 int res2 = 0 ;
44524 PyObject * obj0 = 0 ;
44525 PyObject * obj1 = 0 ;
44526 char * kwnames[] = {
44527 (char *) "self",(char *) "bitmap", NULL
44528 };
44529
44530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44534 }
44535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44537 if (!SWIG_IsOK(res2)) {
44538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44539 }
44540 if (!argp2) {
44541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44542 }
44543 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44544 {
44545 PyThreadState* __tstate = wxPyBeginAllowThreads();
44546 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44547 wxPyEndAllowThreads(__tstate);
44548 if (PyErr_Occurred()) SWIG_fail;
44549 }
44550 resultobj = SWIG_Py_Void();
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44558 PyObject *resultobj = 0;
44559 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44560 wxBitmap *result = 0 ;
44561 void *argp1 = 0 ;
44562 int res1 = 0 ;
44563 PyObject *swig_obj[1] ;
44564
44565 if (!args) SWIG_fail;
44566 swig_obj[0] = args;
44567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44570 }
44571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44572 {
44573 PyThreadState* __tstate = wxPyBeginAllowThreads();
44574 {
44575 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44576 result = (wxBitmap *) &_result_ref;
44577 }
44578 wxPyEndAllowThreads(__tstate);
44579 if (PyErr_Occurred()) SWIG_fail;
44580 }
44581 {
44582 wxBitmap* resultptr = new wxBitmap(*result);
44583 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44584 }
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44592 PyObject *resultobj = 0;
44593 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44594 wxFont *arg2 = 0 ;
44595 void *argp1 = 0 ;
44596 int res1 = 0 ;
44597 void *argp2 = 0 ;
44598 int res2 = 0 ;
44599 PyObject * obj0 = 0 ;
44600 PyObject * obj1 = 0 ;
44601 char * kwnames[] = {
44602 (char *) "self",(char *) "font", NULL
44603 };
44604
44605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44607 if (!SWIG_IsOK(res1)) {
44608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44609 }
44610 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44611 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44612 if (!SWIG_IsOK(res2)) {
44613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44614 }
44615 if (!argp2) {
44616 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44617 }
44618 arg2 = reinterpret_cast< wxFont * >(argp2);
44619 {
44620 PyThreadState* __tstate = wxPyBeginAllowThreads();
44621 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44622 wxPyEndAllowThreads(__tstate);
44623 if (PyErr_Occurred()) SWIG_fail;
44624 }
44625 resultobj = SWIG_Py_Void();
44626 return resultobj;
44627 fail:
44628 return NULL;
44629 }
44630
44631
44632 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44633 PyObject *resultobj = 0;
44634 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44635 wxFont result;
44636 void *argp1 = 0 ;
44637 int res1 = 0 ;
44638 PyObject *swig_obj[1] ;
44639
44640 if (!args) SWIG_fail;
44641 swig_obj[0] = args;
44642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44643 if (!SWIG_IsOK(res1)) {
44644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44645 }
44646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44647 {
44648 PyThreadState* __tstate = wxPyBeginAllowThreads();
44649 result = wxMenuItem_GetFont(arg1);
44650 wxPyEndAllowThreads(__tstate);
44651 if (PyErr_Occurred()) SWIG_fail;
44652 }
44653 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44654 return resultobj;
44655 fail:
44656 return NULL;
44657 }
44658
44659
44660 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44661 PyObject *resultobj = 0;
44662 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44663 wxColour *arg2 = 0 ;
44664 void *argp1 = 0 ;
44665 int res1 = 0 ;
44666 wxColour temp2 ;
44667 PyObject * obj0 = 0 ;
44668 PyObject * obj1 = 0 ;
44669 char * kwnames[] = {
44670 (char *) "self",(char *) "colText", NULL
44671 };
44672
44673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44675 if (!SWIG_IsOK(res1)) {
44676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44677 }
44678 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44679 {
44680 arg2 = &temp2;
44681 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44682 }
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 resultobj = SWIG_Py_Void();
44690 return resultobj;
44691 fail:
44692 return NULL;
44693 }
44694
44695
44696 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44697 PyObject *resultobj = 0;
44698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44699 wxColour result;
44700 void *argp1 = 0 ;
44701 int res1 = 0 ;
44702 PyObject *swig_obj[1] ;
44703
44704 if (!args) SWIG_fail;
44705 swig_obj[0] = args;
44706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44707 if (!SWIG_IsOK(res1)) {
44708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44709 }
44710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 result = wxMenuItem_GetTextColour(arg1);
44714 wxPyEndAllowThreads(__tstate);
44715 if (PyErr_Occurred()) SWIG_fail;
44716 }
44717 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44727 wxColour *arg2 = 0 ;
44728 void *argp1 = 0 ;
44729 int res1 = 0 ;
44730 wxColour temp2 ;
44731 PyObject * obj0 = 0 ;
44732 PyObject * obj1 = 0 ;
44733 char * kwnames[] = {
44734 (char *) "self",(char *) "colBack", NULL
44735 };
44736
44737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44739 if (!SWIG_IsOK(res1)) {
44740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44741 }
44742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44743 {
44744 arg2 = &temp2;
44745 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44746 }
44747 {
44748 PyThreadState* __tstate = wxPyBeginAllowThreads();
44749 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44750 wxPyEndAllowThreads(__tstate);
44751 if (PyErr_Occurred()) SWIG_fail;
44752 }
44753 resultobj = SWIG_Py_Void();
44754 return resultobj;
44755 fail:
44756 return NULL;
44757 }
44758
44759
44760 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44761 PyObject *resultobj = 0;
44762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44763 wxColour result;
44764 void *argp1 = 0 ;
44765 int res1 = 0 ;
44766 PyObject *swig_obj[1] ;
44767
44768 if (!args) SWIG_fail;
44769 swig_obj[0] = args;
44770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44771 if (!SWIG_IsOK(res1)) {
44772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44773 }
44774 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44775 {
44776 PyThreadState* __tstate = wxPyBeginAllowThreads();
44777 result = wxMenuItem_GetBackgroundColour(arg1);
44778 wxPyEndAllowThreads(__tstate);
44779 if (PyErr_Occurred()) SWIG_fail;
44780 }
44781 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44782 return resultobj;
44783 fail:
44784 return NULL;
44785 }
44786
44787
44788 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44789 PyObject *resultobj = 0;
44790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44791 wxBitmap *arg2 = 0 ;
44792 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44793 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 void *argp2 = 0 ;
44797 int res2 = 0 ;
44798 void *argp3 = 0 ;
44799 int res3 = 0 ;
44800 PyObject * obj0 = 0 ;
44801 PyObject * obj1 = 0 ;
44802 PyObject * obj2 = 0 ;
44803 char * kwnames[] = {
44804 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44805 };
44806
44807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44809 if (!SWIG_IsOK(res1)) {
44810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44811 }
44812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44813 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44814 if (!SWIG_IsOK(res2)) {
44815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44816 }
44817 if (!argp2) {
44818 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44819 }
44820 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44821 if (obj2) {
44822 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44823 if (!SWIG_IsOK(res3)) {
44824 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44825 }
44826 if (!argp3) {
44827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44828 }
44829 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44830 }
44831 {
44832 PyThreadState* __tstate = wxPyBeginAllowThreads();
44833 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_Py_Void();
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44845 PyObject *resultobj = 0;
44846 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44847 wxBitmap *arg2 = 0 ;
44848 void *argp1 = 0 ;
44849 int res1 = 0 ;
44850 void *argp2 = 0 ;
44851 int res2 = 0 ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 char * kwnames[] = {
44855 (char *) "self",(char *) "bmpDisabled", NULL
44856 };
44857
44858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44860 if (!SWIG_IsOK(res1)) {
44861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44862 }
44863 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44865 if (!SWIG_IsOK(res2)) {
44866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44867 }
44868 if (!argp2) {
44869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44870 }
44871 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44872 {
44873 PyThreadState* __tstate = wxPyBeginAllowThreads();
44874 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44875 wxPyEndAllowThreads(__tstate);
44876 if (PyErr_Occurred()) SWIG_fail;
44877 }
44878 resultobj = SWIG_Py_Void();
44879 return resultobj;
44880 fail:
44881 return NULL;
44882 }
44883
44884
44885 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44886 PyObject *resultobj = 0;
44887 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44888 wxBitmap *result = 0 ;
44889 void *argp1 = 0 ;
44890 int res1 = 0 ;
44891 PyObject *swig_obj[1] ;
44892
44893 if (!args) SWIG_fail;
44894 swig_obj[0] = args;
44895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44896 if (!SWIG_IsOK(res1)) {
44897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44898 }
44899 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44900 {
44901 PyThreadState* __tstate = wxPyBeginAllowThreads();
44902 {
44903 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44904 result = (wxBitmap *) &_result_ref;
44905 }
44906 wxPyEndAllowThreads(__tstate);
44907 if (PyErr_Occurred()) SWIG_fail;
44908 }
44909 {
44910 wxBitmap* resultptr = new wxBitmap(*result);
44911 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44912 }
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj = 0;
44921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44922 int arg2 ;
44923 void *argp1 = 0 ;
44924 int res1 = 0 ;
44925 int val2 ;
44926 int ecode2 = 0 ;
44927 PyObject * obj0 = 0 ;
44928 PyObject * obj1 = 0 ;
44929 char * kwnames[] = {
44930 (char *) "self",(char *) "nWidth", NULL
44931 };
44932
44933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44935 if (!SWIG_IsOK(res1)) {
44936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44937 }
44938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44939 ecode2 = SWIG_AsVal_int(obj1, &val2);
44940 if (!SWIG_IsOK(ecode2)) {
44941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44942 }
44943 arg2 = static_cast< int >(val2);
44944 {
44945 PyThreadState* __tstate = wxPyBeginAllowThreads();
44946 wxMenuItem_SetMarginWidth(arg1,arg2);
44947 wxPyEndAllowThreads(__tstate);
44948 if (PyErr_Occurred()) SWIG_fail;
44949 }
44950 resultobj = SWIG_Py_Void();
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44958 PyObject *resultobj = 0;
44959 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44960 int result;
44961 void *argp1 = 0 ;
44962 int res1 = 0 ;
44963 PyObject *swig_obj[1] ;
44964
44965 if (!args) SWIG_fail;
44966 swig_obj[0] = args;
44967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44968 if (!SWIG_IsOK(res1)) {
44969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44970 }
44971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44972 {
44973 PyThreadState* __tstate = wxPyBeginAllowThreads();
44974 result = (int)wxMenuItem_GetMarginWidth(arg1);
44975 wxPyEndAllowThreads(__tstate);
44976 if (PyErr_Occurred()) SWIG_fail;
44977 }
44978 resultobj = SWIG_From_int(static_cast< int >(result));
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44986 PyObject *resultobj = 0;
44987 int result;
44988
44989 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44990 {
44991 PyThreadState* __tstate = wxPyBeginAllowThreads();
44992 result = (int)wxMenuItem_GetDefaultMarginWidth();
44993 wxPyEndAllowThreads(__tstate);
44994 if (PyErr_Occurred()) SWIG_fail;
44995 }
44996 resultobj = SWIG_From_int(static_cast< int >(result));
44997 return resultobj;
44998 fail:
44999 return NULL;
45000 }
45001
45002
45003 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45004 PyObject *resultobj = 0;
45005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45006 bool result;
45007 void *argp1 = 0 ;
45008 int res1 = 0 ;
45009 PyObject *swig_obj[1] ;
45010
45011 if (!args) SWIG_fail;
45012 swig_obj[0] = args;
45013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45014 if (!SWIG_IsOK(res1)) {
45015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45016 }
45017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45018 {
45019 PyThreadState* __tstate = wxPyBeginAllowThreads();
45020 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
45021 wxPyEndAllowThreads(__tstate);
45022 if (PyErr_Occurred()) SWIG_fail;
45023 }
45024 {
45025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45026 }
45027 return resultobj;
45028 fail:
45029 return NULL;
45030 }
45031
45032
45033 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45034 PyObject *resultobj = 0;
45035 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45036 bool arg2 = (bool) true ;
45037 void *argp1 = 0 ;
45038 int res1 = 0 ;
45039 bool val2 ;
45040 int ecode2 = 0 ;
45041 PyObject * obj0 = 0 ;
45042 PyObject * obj1 = 0 ;
45043 char * kwnames[] = {
45044 (char *) "self",(char *) "ownerDrawn", NULL
45045 };
45046
45047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
45048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45049 if (!SWIG_IsOK(res1)) {
45050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45051 }
45052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45053 if (obj1) {
45054 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45055 if (!SWIG_IsOK(ecode2)) {
45056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
45057 }
45058 arg2 = static_cast< bool >(val2);
45059 }
45060 {
45061 PyThreadState* __tstate = wxPyBeginAllowThreads();
45062 wxMenuItem_SetOwnerDrawn(arg1,arg2);
45063 wxPyEndAllowThreads(__tstate);
45064 if (PyErr_Occurred()) SWIG_fail;
45065 }
45066 resultobj = SWIG_Py_Void();
45067 return resultobj;
45068 fail:
45069 return NULL;
45070 }
45071
45072
45073 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45074 PyObject *resultobj = 0;
45075 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45076 void *argp1 = 0 ;
45077 int res1 = 0 ;
45078 PyObject *swig_obj[1] ;
45079
45080 if (!args) SWIG_fail;
45081 swig_obj[0] = args;
45082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45083 if (!SWIG_IsOK(res1)) {
45084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45085 }
45086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45087 {
45088 PyThreadState* __tstate = wxPyBeginAllowThreads();
45089 wxMenuItem_ResetOwnerDrawn(arg1);
45090 wxPyEndAllowThreads(__tstate);
45091 if (PyErr_Occurred()) SWIG_fail;
45092 }
45093 resultobj = SWIG_Py_Void();
45094 return resultobj;
45095 fail:
45096 return NULL;
45097 }
45098
45099
45100 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45101 PyObject *obj;
45102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45103 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
45104 return SWIG_Py_Void();
45105 }
45106
45107 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45108 return SWIG_Python_InitShadowInstance(args);
45109 }
45110
45111 SWIGINTERN int ControlNameStr_set(PyObject *) {
45112 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
45113 return 1;
45114 }
45115
45116
45117 SWIGINTERN PyObject *ControlNameStr_get(void) {
45118 PyObject *pyobj = 0;
45119
45120 {
45121 #if wxUSE_UNICODE
45122 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45123 #else
45124 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
45125 #endif
45126 }
45127 return pyobj;
45128 }
45129
45130
45131 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45132 PyObject *resultobj = 0;
45133 wxWindow *arg1 = (wxWindow *) 0 ;
45134 int arg2 = (int) -1 ;
45135 wxPoint const &arg3_defvalue = wxDefaultPosition ;
45136 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
45137 wxSize const &arg4_defvalue = wxDefaultSize ;
45138 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
45139 long arg5 = (long) 0 ;
45140 wxValidator const &arg6_defvalue = wxDefaultValidator ;
45141 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
45142 wxString const &arg7_defvalue = wxPyControlNameStr ;
45143 wxString *arg7 = (wxString *) &arg7_defvalue ;
45144 wxControl *result = 0 ;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 int val2 ;
45148 int ecode2 = 0 ;
45149 wxPoint temp3 ;
45150 wxSize temp4 ;
45151 long val5 ;
45152 int ecode5 = 0 ;
45153 void *argp6 = 0 ;
45154 int res6 = 0 ;
45155 bool temp7 = false ;
45156 PyObject * obj0 = 0 ;
45157 PyObject * obj1 = 0 ;
45158 PyObject * obj2 = 0 ;
45159 PyObject * obj3 = 0 ;
45160 PyObject * obj4 = 0 ;
45161 PyObject * obj5 = 0 ;
45162 PyObject * obj6 = 0 ;
45163 char * kwnames[] = {
45164 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45165 };
45166
45167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
45168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45169 if (!SWIG_IsOK(res1)) {
45170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
45171 }
45172 arg1 = reinterpret_cast< wxWindow * >(argp1);
45173 if (obj1) {
45174 ecode2 = SWIG_AsVal_int(obj1, &val2);
45175 if (!SWIG_IsOK(ecode2)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
45177 }
45178 arg2 = static_cast< int >(val2);
45179 }
45180 if (obj2) {
45181 {
45182 arg3 = &temp3;
45183 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
45184 }
45185 }
45186 if (obj3) {
45187 {
45188 arg4 = &temp4;
45189 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
45190 }
45191 }
45192 if (obj4) {
45193 ecode5 = SWIG_AsVal_long(obj4, &val5);
45194 if (!SWIG_IsOK(ecode5)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
45196 }
45197 arg5 = static_cast< long >(val5);
45198 }
45199 if (obj5) {
45200 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
45201 if (!SWIG_IsOK(res6)) {
45202 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45203 }
45204 if (!argp6) {
45205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
45206 }
45207 arg6 = reinterpret_cast< wxValidator * >(argp6);
45208 }
45209 if (obj6) {
45210 {
45211 arg7 = wxString_in_helper(obj6);
45212 if (arg7 == NULL) SWIG_fail;
45213 temp7 = true;
45214 }
45215 }
45216 {
45217 if (!wxPyCheckForApp()) SWIG_fail;
45218 PyThreadState* __tstate = wxPyBeginAllowThreads();
45219 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
45220 wxPyEndAllowThreads(__tstate);
45221 if (PyErr_Occurred()) SWIG_fail;
45222 }
45223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
45224 {
45225 if (temp7)
45226 delete arg7;
45227 }
45228 return resultobj;
45229 fail:
45230 {
45231 if (temp7)
45232 delete arg7;
45233 }
45234 return NULL;
45235 }
45236
45237
45238 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45239 PyObject *resultobj = 0;
45240 wxControl *result = 0 ;
45241
45242 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
45243 {
45244 if (!wxPyCheckForApp()) SWIG_fail;
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 result = (wxControl *)new wxControl();
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45258 PyObject *resultobj = 0;
45259 wxControl *arg1 = (wxControl *) 0 ;
45260 wxWindow *arg2 = (wxWindow *) 0 ;
45261 int arg3 = (int) -1 ;
45262 wxPoint const &arg4_defvalue = wxDefaultPosition ;
45263 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
45264 wxSize const &arg5_defvalue = wxDefaultSize ;
45265 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
45266 long arg6 = (long) 0 ;
45267 wxValidator const &arg7_defvalue = wxDefaultValidator ;
45268 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
45269 wxString const &arg8_defvalue = wxPyControlNameStr ;
45270 wxString *arg8 = (wxString *) &arg8_defvalue ;
45271 bool result;
45272 void *argp1 = 0 ;
45273 int res1 = 0 ;
45274 void *argp2 = 0 ;
45275 int res2 = 0 ;
45276 int val3 ;
45277 int ecode3 = 0 ;
45278 wxPoint temp4 ;
45279 wxSize temp5 ;
45280 long val6 ;
45281 int ecode6 = 0 ;
45282 void *argp7 = 0 ;
45283 int res7 = 0 ;
45284 bool temp8 = false ;
45285 PyObject * obj0 = 0 ;
45286 PyObject * obj1 = 0 ;
45287 PyObject * obj2 = 0 ;
45288 PyObject * obj3 = 0 ;
45289 PyObject * obj4 = 0 ;
45290 PyObject * obj5 = 0 ;
45291 PyObject * obj6 = 0 ;
45292 PyObject * obj7 = 0 ;
45293 char * kwnames[] = {
45294 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
45295 };
45296
45297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
45298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
45301 }
45302 arg1 = reinterpret_cast< wxControl * >(argp1);
45303 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45304 if (!SWIG_IsOK(res2)) {
45305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
45306 }
45307 arg2 = reinterpret_cast< wxWindow * >(argp2);
45308 if (obj2) {
45309 ecode3 = SWIG_AsVal_int(obj2, &val3);
45310 if (!SWIG_IsOK(ecode3)) {
45311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
45312 }
45313 arg3 = static_cast< int >(val3);
45314 }
45315 if (obj3) {
45316 {
45317 arg4 = &temp4;
45318 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
45319 }
45320 }
45321 if (obj4) {
45322 {
45323 arg5 = &temp5;
45324 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
45325 }
45326 }
45327 if (obj5) {
45328 ecode6 = SWIG_AsVal_long(obj5, &val6);
45329 if (!SWIG_IsOK(ecode6)) {
45330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
45331 }
45332 arg6 = static_cast< long >(val6);
45333 }
45334 if (obj6) {
45335 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
45336 if (!SWIG_IsOK(res7)) {
45337 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45338 }
45339 if (!argp7) {
45340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
45341 }
45342 arg7 = reinterpret_cast< wxValidator * >(argp7);
45343 }
45344 if (obj7) {
45345 {
45346 arg8 = wxString_in_helper(obj7);
45347 if (arg8 == NULL) SWIG_fail;
45348 temp8 = true;
45349 }
45350 }
45351 {
45352 PyThreadState* __tstate = wxPyBeginAllowThreads();
45353 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
45354 wxPyEndAllowThreads(__tstate);
45355 if (PyErr_Occurred()) SWIG_fail;
45356 }
45357 {
45358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45359 }
45360 {
45361 if (temp8)
45362 delete arg8;
45363 }
45364 return resultobj;
45365 fail:
45366 {
45367 if (temp8)
45368 delete arg8;
45369 }
45370 return NULL;
45371 }
45372
45373
45374 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45375 PyObject *resultobj = 0;
45376 wxControl *arg1 = (wxControl *) 0 ;
45377 int result;
45378 void *argp1 = 0 ;
45379 int res1 = 0 ;
45380 PyObject *swig_obj[1] ;
45381
45382 if (!args) SWIG_fail;
45383 swig_obj[0] = args;
45384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45385 if (!SWIG_IsOK(res1)) {
45386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
45387 }
45388 arg1 = reinterpret_cast< wxControl * >(argp1);
45389 {
45390 PyThreadState* __tstate = wxPyBeginAllowThreads();
45391 result = (int)((wxControl const *)arg1)->GetAlignment();
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 resultobj = SWIG_From_int(static_cast< int >(result));
45396 return resultobj;
45397 fail:
45398 return NULL;
45399 }
45400
45401
45402 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45403 PyObject *resultobj = 0;
45404 wxControl *arg1 = (wxControl *) 0 ;
45405 wxString result;
45406 void *argp1 = 0 ;
45407 int res1 = 0 ;
45408 PyObject *swig_obj[1] ;
45409
45410 if (!args) SWIG_fail;
45411 swig_obj[0] = args;
45412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45413 if (!SWIG_IsOK(res1)) {
45414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
45415 }
45416 arg1 = reinterpret_cast< wxControl * >(argp1);
45417 {
45418 PyThreadState* __tstate = wxPyBeginAllowThreads();
45419 result = ((wxControl const *)arg1)->GetLabelText();
45420 wxPyEndAllowThreads(__tstate);
45421 if (PyErr_Occurred()) SWIG_fail;
45422 }
45423 {
45424 #if wxUSE_UNICODE
45425 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45426 #else
45427 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45428 #endif
45429 }
45430 return resultobj;
45431 fail:
45432 return NULL;
45433 }
45434
45435
45436 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45437 PyObject *resultobj = 0;
45438 wxControl *arg1 = (wxControl *) 0 ;
45439 wxCommandEvent *arg2 = 0 ;
45440 void *argp1 = 0 ;
45441 int res1 = 0 ;
45442 void *argp2 = 0 ;
45443 int res2 = 0 ;
45444 PyObject * obj0 = 0 ;
45445 PyObject * obj1 = 0 ;
45446 char * kwnames[] = {
45447 (char *) "self",(char *) "event", NULL
45448 };
45449
45450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
45451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
45452 if (!SWIG_IsOK(res1)) {
45453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
45454 }
45455 arg1 = reinterpret_cast< wxControl * >(argp1);
45456 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
45457 if (!SWIG_IsOK(res2)) {
45458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45459 }
45460 if (!argp2) {
45461 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
45462 }
45463 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
45464 {
45465 PyThreadState* __tstate = wxPyBeginAllowThreads();
45466 (arg1)->Command(*arg2);
45467 wxPyEndAllowThreads(__tstate);
45468 if (PyErr_Occurred()) SWIG_fail;
45469 }
45470 resultobj = SWIG_Py_Void();
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45478 PyObject *resultobj = 0;
45479 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45480 SwigValueWrapper<wxVisualAttributes > result;
45481 int val1 ;
45482 int ecode1 = 0 ;
45483 PyObject * obj0 = 0 ;
45484 char * kwnames[] = {
45485 (char *) "variant", NULL
45486 };
45487
45488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45489 if (obj0) {
45490 ecode1 = SWIG_AsVal_int(obj0, &val1);
45491 if (!SWIG_IsOK(ecode1)) {
45492 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45493 }
45494 arg1 = static_cast< wxWindowVariant >(val1);
45495 }
45496 {
45497 if (!wxPyCheckForApp()) SWIG_fail;
45498 PyThreadState* __tstate = wxPyBeginAllowThreads();
45499 result = wxControl::GetClassDefaultAttributes(arg1);
45500 wxPyEndAllowThreads(__tstate);
45501 if (PyErr_Occurred()) SWIG_fail;
45502 }
45503 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45504 return resultobj;
45505 fail:
45506 return NULL;
45507 }
45508
45509
45510 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45511 PyObject *obj;
45512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45513 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45514 return SWIG_Py_Void();
45515 }
45516
45517 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45518 return SWIG_Python_InitShadowInstance(args);
45519 }
45520
45521 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45522 PyObject *resultobj = 0;
45523 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45524 wxString *arg2 = 0 ;
45525 PyObject *arg3 = (PyObject *) NULL ;
45526 int result;
45527 void *argp1 = 0 ;
45528 int res1 = 0 ;
45529 bool temp2 = false ;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 PyObject * obj2 = 0 ;
45533 char * kwnames[] = {
45534 (char *) "self",(char *) "item",(char *) "clientData", NULL
45535 };
45536
45537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45539 if (!SWIG_IsOK(res1)) {
45540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45541 }
45542 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45543 {
45544 arg2 = wxString_in_helper(obj1);
45545 if (arg2 == NULL) SWIG_fail;
45546 temp2 = true;
45547 }
45548 if (obj2) {
45549 arg3 = obj2;
45550 }
45551 {
45552 PyThreadState* __tstate = wxPyBeginAllowThreads();
45553 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45554 wxPyEndAllowThreads(__tstate);
45555 if (PyErr_Occurred()) SWIG_fail;
45556 }
45557 resultobj = SWIG_From_int(static_cast< int >(result));
45558 {
45559 if (temp2)
45560 delete arg2;
45561 }
45562 return resultobj;
45563 fail:
45564 {
45565 if (temp2)
45566 delete arg2;
45567 }
45568 return NULL;
45569 }
45570
45571
45572 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45573 PyObject *resultobj = 0;
45574 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45575 wxArrayString *arg2 = 0 ;
45576 void *argp1 = 0 ;
45577 int res1 = 0 ;
45578 bool temp2 = false ;
45579 PyObject * obj0 = 0 ;
45580 PyObject * obj1 = 0 ;
45581 char * kwnames[] = {
45582 (char *) "self",(char *) "strings", NULL
45583 };
45584
45585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45587 if (!SWIG_IsOK(res1)) {
45588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45589 }
45590 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45591 {
45592 if (! PySequence_Check(obj1)) {
45593 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45594 SWIG_fail;
45595 }
45596 arg2 = new wxArrayString;
45597 temp2 = true;
45598 int i, len=PySequence_Length(obj1);
45599 for (i=0; i<len; i++) {
45600 PyObject* item = PySequence_GetItem(obj1, i);
45601 wxString* s = wxString_in_helper(item);
45602 if (PyErr_Occurred()) SWIG_fail;
45603 arg2->Add(*s);
45604 delete s;
45605 Py_DECREF(item);
45606 }
45607 }
45608 {
45609 PyThreadState* __tstate = wxPyBeginAllowThreads();
45610 (arg1)->Append((wxArrayString const &)*arg2);
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 resultobj = SWIG_Py_Void();
45615 {
45616 if (temp2) delete arg2;
45617 }
45618 return resultobj;
45619 fail:
45620 {
45621 if (temp2) delete arg2;
45622 }
45623 return NULL;
45624 }
45625
45626
45627 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45628 PyObject *resultobj = 0;
45629 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45630 wxString *arg2 = 0 ;
45631 unsigned int arg3 ;
45632 PyObject *arg4 = (PyObject *) NULL ;
45633 int result;
45634 void *argp1 = 0 ;
45635 int res1 = 0 ;
45636 bool temp2 = false ;
45637 unsigned int val3 ;
45638 int ecode3 = 0 ;
45639 PyObject * obj0 = 0 ;
45640 PyObject * obj1 = 0 ;
45641 PyObject * obj2 = 0 ;
45642 PyObject * obj3 = 0 ;
45643 char * kwnames[] = {
45644 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45645 };
45646
45647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45649 if (!SWIG_IsOK(res1)) {
45650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45651 }
45652 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45653 {
45654 arg2 = wxString_in_helper(obj1);
45655 if (arg2 == NULL) SWIG_fail;
45656 temp2 = true;
45657 }
45658 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45659 if (!SWIG_IsOK(ecode3)) {
45660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45661 }
45662 arg3 = static_cast< unsigned int >(val3);
45663 if (obj3) {
45664 arg4 = obj3;
45665 }
45666 {
45667 PyThreadState* __tstate = wxPyBeginAllowThreads();
45668 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45669 wxPyEndAllowThreads(__tstate);
45670 if (PyErr_Occurred()) SWIG_fail;
45671 }
45672 resultobj = SWIG_From_int(static_cast< int >(result));
45673 {
45674 if (temp2)
45675 delete arg2;
45676 }
45677 return resultobj;
45678 fail:
45679 {
45680 if (temp2)
45681 delete arg2;
45682 }
45683 return NULL;
45684 }
45685
45686
45687 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45688 PyObject *resultobj = 0;
45689 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 PyObject *swig_obj[1] ;
45693
45694 if (!args) SWIG_fail;
45695 swig_obj[0] = args;
45696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45699 }
45700 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45701 {
45702 PyThreadState* __tstate = wxPyBeginAllowThreads();
45703 (arg1)->Clear();
45704 wxPyEndAllowThreads(__tstate);
45705 if (PyErr_Occurred()) SWIG_fail;
45706 }
45707 resultobj = SWIG_Py_Void();
45708 return resultobj;
45709 fail:
45710 return NULL;
45711 }
45712
45713
45714 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45715 PyObject *resultobj = 0;
45716 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45717 unsigned int arg2 ;
45718 void *argp1 = 0 ;
45719 int res1 = 0 ;
45720 unsigned int val2 ;
45721 int ecode2 = 0 ;
45722 PyObject * obj0 = 0 ;
45723 PyObject * obj1 = 0 ;
45724 char * kwnames[] = {
45725 (char *) "self",(char *) "n", NULL
45726 };
45727
45728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45730 if (!SWIG_IsOK(res1)) {
45731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45732 }
45733 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45734 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45735 if (!SWIG_IsOK(ecode2)) {
45736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45737 }
45738 arg2 = static_cast< unsigned int >(val2);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 (arg1)->Delete(arg2);
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 resultobj = SWIG_Py_Void();
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45755 unsigned int arg2 ;
45756 PyObject *result = 0 ;
45757 void *argp1 = 0 ;
45758 int res1 = 0 ;
45759 unsigned int val2 ;
45760 int ecode2 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 PyObject * obj1 = 0 ;
45763 char * kwnames[] = {
45764 (char *) "self",(char *) "n", NULL
45765 };
45766
45767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45769 if (!SWIG_IsOK(res1)) {
45770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45771 }
45772 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45773 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45774 if (!SWIG_IsOK(ecode2)) {
45775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45776 }
45777 arg2 = static_cast< unsigned int >(val2);
45778 {
45779 PyThreadState* __tstate = wxPyBeginAllowThreads();
45780 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45781 wxPyEndAllowThreads(__tstate);
45782 if (PyErr_Occurred()) SWIG_fail;
45783 }
45784 resultobj = result;
45785 return resultobj;
45786 fail:
45787 return NULL;
45788 }
45789
45790
45791 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45792 PyObject *resultobj = 0;
45793 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45794 unsigned int arg2 ;
45795 PyObject *arg3 = (PyObject *) 0 ;
45796 void *argp1 = 0 ;
45797 int res1 = 0 ;
45798 unsigned int val2 ;
45799 int ecode2 = 0 ;
45800 PyObject * obj0 = 0 ;
45801 PyObject * obj1 = 0 ;
45802 PyObject * obj2 = 0 ;
45803 char * kwnames[] = {
45804 (char *) "self",(char *) "n",(char *) "clientData", NULL
45805 };
45806
45807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45809 if (!SWIG_IsOK(res1)) {
45810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45811 }
45812 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45813 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45814 if (!SWIG_IsOK(ecode2)) {
45815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45816 }
45817 arg2 = static_cast< unsigned int >(val2);
45818 arg3 = obj2;
45819 {
45820 PyThreadState* __tstate = wxPyBeginAllowThreads();
45821 wxItemContainer_SetClientData(arg1,arg2,arg3);
45822 wxPyEndAllowThreads(__tstate);
45823 if (PyErr_Occurred()) SWIG_fail;
45824 }
45825 resultobj = SWIG_Py_Void();
45826 return resultobj;
45827 fail:
45828 return NULL;
45829 }
45830
45831
45832 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45833 PyObject *resultobj = 0;
45834 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45835 unsigned int result;
45836 void *argp1 = 0 ;
45837 int res1 = 0 ;
45838 PyObject *swig_obj[1] ;
45839
45840 if (!args) SWIG_fail;
45841 swig_obj[0] = args;
45842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45843 if (!SWIG_IsOK(res1)) {
45844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45845 }
45846 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45847 {
45848 PyThreadState* __tstate = wxPyBeginAllowThreads();
45849 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45850 wxPyEndAllowThreads(__tstate);
45851 if (PyErr_Occurred()) SWIG_fail;
45852 }
45853 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45854 return resultobj;
45855 fail:
45856 return NULL;
45857 }
45858
45859
45860 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45861 PyObject *resultobj = 0;
45862 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45863 bool result;
45864 void *argp1 = 0 ;
45865 int res1 = 0 ;
45866 PyObject *swig_obj[1] ;
45867
45868 if (!args) SWIG_fail;
45869 swig_obj[0] = args;
45870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45871 if (!SWIG_IsOK(res1)) {
45872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45873 }
45874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45875 {
45876 PyThreadState* __tstate = wxPyBeginAllowThreads();
45877 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45878 wxPyEndAllowThreads(__tstate);
45879 if (PyErr_Occurred()) SWIG_fail;
45880 }
45881 {
45882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45883 }
45884 return resultobj;
45885 fail:
45886 return NULL;
45887 }
45888
45889
45890 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45891 PyObject *resultobj = 0;
45892 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45893 unsigned int arg2 ;
45894 wxString result;
45895 void *argp1 = 0 ;
45896 int res1 = 0 ;
45897 unsigned int val2 ;
45898 int ecode2 = 0 ;
45899 PyObject * obj0 = 0 ;
45900 PyObject * obj1 = 0 ;
45901 char * kwnames[] = {
45902 (char *) "self",(char *) "n", NULL
45903 };
45904
45905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45907 if (!SWIG_IsOK(res1)) {
45908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45909 }
45910 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45911 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45912 if (!SWIG_IsOK(ecode2)) {
45913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45914 }
45915 arg2 = static_cast< unsigned int >(val2);
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 {
45923 #if wxUSE_UNICODE
45924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45925 #else
45926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45927 #endif
45928 }
45929 return resultobj;
45930 fail:
45931 return NULL;
45932 }
45933
45934
45935 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45936 PyObject *resultobj = 0;
45937 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45938 wxArrayString result;
45939 void *argp1 = 0 ;
45940 int res1 = 0 ;
45941 PyObject *swig_obj[1] ;
45942
45943 if (!args) SWIG_fail;
45944 swig_obj[0] = args;
45945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45946 if (!SWIG_IsOK(res1)) {
45947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45948 }
45949 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45950 {
45951 PyThreadState* __tstate = wxPyBeginAllowThreads();
45952 result = ((wxItemContainer const *)arg1)->GetStrings();
45953 wxPyEndAllowThreads(__tstate);
45954 if (PyErr_Occurred()) SWIG_fail;
45955 }
45956 {
45957 resultobj = wxArrayString2PyList_helper(result);
45958 }
45959 return resultobj;
45960 fail:
45961 return NULL;
45962 }
45963
45964
45965 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45966 PyObject *resultobj = 0;
45967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45968 unsigned int arg2 ;
45969 wxString *arg3 = 0 ;
45970 void *argp1 = 0 ;
45971 int res1 = 0 ;
45972 unsigned int val2 ;
45973 int ecode2 = 0 ;
45974 bool temp3 = false ;
45975 PyObject * obj0 = 0 ;
45976 PyObject * obj1 = 0 ;
45977 PyObject * obj2 = 0 ;
45978 char * kwnames[] = {
45979 (char *) "self",(char *) "n",(char *) "s", NULL
45980 };
45981
45982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45984 if (!SWIG_IsOK(res1)) {
45985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45986 }
45987 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45988 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45989 if (!SWIG_IsOK(ecode2)) {
45990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45991 }
45992 arg2 = static_cast< unsigned int >(val2);
45993 {
45994 arg3 = wxString_in_helper(obj2);
45995 if (arg3 == NULL) SWIG_fail;
45996 temp3 = true;
45997 }
45998 {
45999 PyThreadState* __tstate = wxPyBeginAllowThreads();
46000 (arg1)->SetString(arg2,(wxString const &)*arg3);
46001 wxPyEndAllowThreads(__tstate);
46002 if (PyErr_Occurred()) SWIG_fail;
46003 }
46004 resultobj = SWIG_Py_Void();
46005 {
46006 if (temp3)
46007 delete arg3;
46008 }
46009 return resultobj;
46010 fail:
46011 {
46012 if (temp3)
46013 delete arg3;
46014 }
46015 return NULL;
46016 }
46017
46018
46019 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46020 PyObject *resultobj = 0;
46021 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46022 wxString *arg2 = 0 ;
46023 int result;
46024 void *argp1 = 0 ;
46025 int res1 = 0 ;
46026 bool temp2 = false ;
46027 PyObject * obj0 = 0 ;
46028 PyObject * obj1 = 0 ;
46029 char * kwnames[] = {
46030 (char *) "self",(char *) "s", NULL
46031 };
46032
46033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
46034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46035 if (!SWIG_IsOK(res1)) {
46036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46037 }
46038 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46039 {
46040 arg2 = wxString_in_helper(obj1);
46041 if (arg2 == NULL) SWIG_fail;
46042 temp2 = true;
46043 }
46044 {
46045 PyThreadState* __tstate = wxPyBeginAllowThreads();
46046 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
46047 wxPyEndAllowThreads(__tstate);
46048 if (PyErr_Occurred()) SWIG_fail;
46049 }
46050 resultobj = SWIG_From_int(static_cast< int >(result));
46051 {
46052 if (temp2)
46053 delete arg2;
46054 }
46055 return resultobj;
46056 fail:
46057 {
46058 if (temp2)
46059 delete arg2;
46060 }
46061 return NULL;
46062 }
46063
46064
46065 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46066 PyObject *resultobj = 0;
46067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46068 int arg2 ;
46069 void *argp1 = 0 ;
46070 int res1 = 0 ;
46071 int val2 ;
46072 int ecode2 = 0 ;
46073 PyObject * obj0 = 0 ;
46074 PyObject * obj1 = 0 ;
46075 char * kwnames[] = {
46076 (char *) "self",(char *) "n", NULL
46077 };
46078
46079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46081 if (!SWIG_IsOK(res1)) {
46082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46083 }
46084 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46085 ecode2 = SWIG_AsVal_int(obj1, &val2);
46086 if (!SWIG_IsOK(ecode2)) {
46087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
46088 }
46089 arg2 = static_cast< int >(val2);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 (arg1)->SetSelection(arg2);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 resultobj = SWIG_Py_Void();
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46104 PyObject *resultobj = 0;
46105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46106 int result;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 PyObject *swig_obj[1] ;
46110
46111 if (!args) SWIG_fail;
46112 swig_obj[0] = args;
46113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46114 if (!SWIG_IsOK(res1)) {
46115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46116 }
46117 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46118 {
46119 PyThreadState* __tstate = wxPyBeginAllowThreads();
46120 result = (int)((wxItemContainer const *)arg1)->GetSelection();
46121 wxPyEndAllowThreads(__tstate);
46122 if (PyErr_Occurred()) SWIG_fail;
46123 }
46124 resultobj = SWIG_From_int(static_cast< int >(result));
46125 return resultobj;
46126 fail:
46127 return NULL;
46128 }
46129
46130
46131 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46132 PyObject *resultobj = 0;
46133 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46134 wxString *arg2 = 0 ;
46135 bool result;
46136 void *argp1 = 0 ;
46137 int res1 = 0 ;
46138 bool temp2 = false ;
46139 PyObject * obj0 = 0 ;
46140 PyObject * obj1 = 0 ;
46141 char * kwnames[] = {
46142 (char *) "self",(char *) "s", NULL
46143 };
46144
46145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
46146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46147 if (!SWIG_IsOK(res1)) {
46148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46149 }
46150 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46151 {
46152 arg2 = wxString_in_helper(obj1);
46153 if (arg2 == NULL) SWIG_fail;
46154 temp2 = true;
46155 }
46156 {
46157 PyThreadState* __tstate = wxPyBeginAllowThreads();
46158 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
46159 wxPyEndAllowThreads(__tstate);
46160 if (PyErr_Occurred()) SWIG_fail;
46161 }
46162 {
46163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46164 }
46165 {
46166 if (temp2)
46167 delete arg2;
46168 }
46169 return resultobj;
46170 fail:
46171 {
46172 if (temp2)
46173 delete arg2;
46174 }
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46180 PyObject *resultobj = 0;
46181 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46182 wxString result;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 PyObject *swig_obj[1] ;
46186
46187 if (!args) SWIG_fail;
46188 swig_obj[0] = args;
46189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46190 if (!SWIG_IsOK(res1)) {
46191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
46192 }
46193 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46194 {
46195 PyThreadState* __tstate = wxPyBeginAllowThreads();
46196 result = ((wxItemContainer const *)arg1)->GetStringSelection();
46197 wxPyEndAllowThreads(__tstate);
46198 if (PyErr_Occurred()) SWIG_fail;
46199 }
46200 {
46201 #if wxUSE_UNICODE
46202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46203 #else
46204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46205 #endif
46206 }
46207 return resultobj;
46208 fail:
46209 return NULL;
46210 }
46211
46212
46213 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46214 PyObject *resultobj = 0;
46215 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
46216 int arg2 ;
46217 void *argp1 = 0 ;
46218 int res1 = 0 ;
46219 int val2 ;
46220 int ecode2 = 0 ;
46221 PyObject * obj0 = 0 ;
46222 PyObject * obj1 = 0 ;
46223 char * kwnames[] = {
46224 (char *) "self",(char *) "n", NULL
46225 };
46226
46227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
46228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
46229 if (!SWIG_IsOK(res1)) {
46230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
46231 }
46232 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
46233 ecode2 = SWIG_AsVal_int(obj1, &val2);
46234 if (!SWIG_IsOK(ecode2)) {
46235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
46236 }
46237 arg2 = static_cast< int >(val2);
46238 {
46239 PyThreadState* __tstate = wxPyBeginAllowThreads();
46240 (arg1)->Select(arg2);
46241 wxPyEndAllowThreads(__tstate);
46242 if (PyErr_Occurred()) SWIG_fail;
46243 }
46244 resultobj = SWIG_Py_Void();
46245 return resultobj;
46246 fail:
46247 return NULL;
46248 }
46249
46250
46251 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46252 PyObject *obj;
46253 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46254 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
46255 return SWIG_Py_Void();
46256 }
46257
46258 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46259 PyObject *obj;
46260 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46261 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
46262 return SWIG_Py_Void();
46263 }
46264
46265 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46266 PyObject *resultobj = 0;
46267 wxSizerItem *result = 0 ;
46268
46269 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (wxSizerItem *)new wxSizerItem();
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 void *argp1 = 0 ;
46287 int res1 = 0 ;
46288 PyObject *swig_obj[1] ;
46289
46290 if (!args) SWIG_fail;
46291 swig_obj[0] = args;
46292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46297 {
46298 PyThreadState* __tstate = wxPyBeginAllowThreads();
46299 delete arg1;
46300
46301 wxPyEndAllowThreads(__tstate);
46302 if (PyErr_Occurred()) SWIG_fail;
46303 }
46304 resultobj = SWIG_Py_Void();
46305 return resultobj;
46306 fail:
46307 return NULL;
46308 }
46309
46310
46311 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46312 PyObject *resultobj = 0;
46313 wxWindow *arg1 = (wxWindow *) 0 ;
46314 int arg2 ;
46315 int arg3 ;
46316 int arg4 ;
46317 PyObject *arg5 = (PyObject *) NULL ;
46318 wxSizerItem *result = 0 ;
46319 void *argp1 = 0 ;
46320 int res1 = 0 ;
46321 int val2 ;
46322 int ecode2 = 0 ;
46323 int val3 ;
46324 int ecode3 = 0 ;
46325 int val4 ;
46326 int ecode4 = 0 ;
46327 PyObject * obj0 = 0 ;
46328 PyObject * obj1 = 0 ;
46329 PyObject * obj2 = 0 ;
46330 PyObject * obj3 = 0 ;
46331 PyObject * obj4 = 0 ;
46332 char * kwnames[] = {
46333 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46334 };
46335
46336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
46338 if (!SWIG_IsOK(res1)) {
46339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
46340 }
46341 arg1 = reinterpret_cast< wxWindow * >(argp1);
46342 ecode2 = SWIG_AsVal_int(obj1, &val2);
46343 if (!SWIG_IsOK(ecode2)) {
46344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
46345 }
46346 arg2 = static_cast< int >(val2);
46347 ecode3 = SWIG_AsVal_int(obj2, &val3);
46348 if (!SWIG_IsOK(ecode3)) {
46349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
46350 }
46351 arg3 = static_cast< int >(val3);
46352 ecode4 = SWIG_AsVal_int(obj3, &val4);
46353 if (!SWIG_IsOK(ecode4)) {
46354 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
46355 }
46356 arg4 = static_cast< int >(val4);
46357 if (obj4) {
46358 arg5 = obj4;
46359 }
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46367 return resultobj;
46368 fail:
46369 return NULL;
46370 }
46371
46372
46373 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46374 PyObject *resultobj = 0;
46375 int arg1 ;
46376 int arg2 ;
46377 int arg3 ;
46378 int arg4 ;
46379 int arg5 ;
46380 PyObject *arg6 = (PyObject *) NULL ;
46381 wxSizerItem *result = 0 ;
46382 int val1 ;
46383 int ecode1 = 0 ;
46384 int val2 ;
46385 int ecode2 = 0 ;
46386 int val3 ;
46387 int ecode3 = 0 ;
46388 int val4 ;
46389 int ecode4 = 0 ;
46390 int val5 ;
46391 int ecode5 = 0 ;
46392 PyObject * obj0 = 0 ;
46393 PyObject * obj1 = 0 ;
46394 PyObject * obj2 = 0 ;
46395 PyObject * obj3 = 0 ;
46396 PyObject * obj4 = 0 ;
46397 PyObject * obj5 = 0 ;
46398 char * kwnames[] = {
46399 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46400 };
46401
46402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46403 ecode1 = SWIG_AsVal_int(obj0, &val1);
46404 if (!SWIG_IsOK(ecode1)) {
46405 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
46406 }
46407 arg1 = static_cast< int >(val1);
46408 ecode2 = SWIG_AsVal_int(obj1, &val2);
46409 if (!SWIG_IsOK(ecode2)) {
46410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
46411 }
46412 arg2 = static_cast< int >(val2);
46413 ecode3 = SWIG_AsVal_int(obj2, &val3);
46414 if (!SWIG_IsOK(ecode3)) {
46415 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
46416 }
46417 arg3 = static_cast< int >(val3);
46418 ecode4 = SWIG_AsVal_int(obj3, &val4);
46419 if (!SWIG_IsOK(ecode4)) {
46420 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
46421 }
46422 arg4 = static_cast< int >(val4);
46423 ecode5 = SWIG_AsVal_int(obj4, &val5);
46424 if (!SWIG_IsOK(ecode5)) {
46425 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
46426 }
46427 arg5 = static_cast< int >(val5);
46428 if (obj5) {
46429 arg6 = obj5;
46430 }
46431 {
46432 PyThreadState* __tstate = wxPyBeginAllowThreads();
46433 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
46434 wxPyEndAllowThreads(__tstate);
46435 if (PyErr_Occurred()) SWIG_fail;
46436 }
46437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46438 return resultobj;
46439 fail:
46440 return NULL;
46441 }
46442
46443
46444 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46445 PyObject *resultobj = 0;
46446 wxSizer *arg1 = (wxSizer *) 0 ;
46447 int arg2 ;
46448 int arg3 ;
46449 int arg4 ;
46450 PyObject *arg5 = (PyObject *) NULL ;
46451 wxSizerItem *result = 0 ;
46452 int res1 = 0 ;
46453 int val2 ;
46454 int ecode2 = 0 ;
46455 int val3 ;
46456 int ecode3 = 0 ;
46457 int val4 ;
46458 int ecode4 = 0 ;
46459 PyObject * obj0 = 0 ;
46460 PyObject * obj1 = 0 ;
46461 PyObject * obj2 = 0 ;
46462 PyObject * obj3 = 0 ;
46463 PyObject * obj4 = 0 ;
46464 char * kwnames[] = {
46465 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46466 };
46467
46468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46469 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46470 if (!SWIG_IsOK(res1)) {
46471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46472 }
46473 ecode2 = SWIG_AsVal_int(obj1, &val2);
46474 if (!SWIG_IsOK(ecode2)) {
46475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46476 }
46477 arg2 = static_cast< int >(val2);
46478 ecode3 = SWIG_AsVal_int(obj2, &val3);
46479 if (!SWIG_IsOK(ecode3)) {
46480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46481 }
46482 arg3 = static_cast< int >(val3);
46483 ecode4 = SWIG_AsVal_int(obj3, &val4);
46484 if (!SWIG_IsOK(ecode4)) {
46485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46486 }
46487 arg4 = static_cast< int >(val4);
46488 if (obj4) {
46489 arg5 = obj4;
46490 }
46491 {
46492 PyThreadState* __tstate = wxPyBeginAllowThreads();
46493 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46494 wxPyEndAllowThreads(__tstate);
46495 if (PyErr_Occurred()) SWIG_fail;
46496 }
46497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46498 return resultobj;
46499 fail:
46500 return NULL;
46501 }
46502
46503
46504 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46505 PyObject *resultobj = 0;
46506 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46507 void *argp1 = 0 ;
46508 int res1 = 0 ;
46509 PyObject *swig_obj[1] ;
46510
46511 if (!args) SWIG_fail;
46512 swig_obj[0] = args;
46513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46514 if (!SWIG_IsOK(res1)) {
46515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46516 }
46517 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46518 {
46519 PyThreadState* __tstate = wxPyBeginAllowThreads();
46520 (arg1)->DeleteWindows();
46521 wxPyEndAllowThreads(__tstate);
46522 if (PyErr_Occurred()) SWIG_fail;
46523 }
46524 resultobj = SWIG_Py_Void();
46525 return resultobj;
46526 fail:
46527 return NULL;
46528 }
46529
46530
46531 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46532 PyObject *resultobj = 0;
46533 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46534 void *argp1 = 0 ;
46535 int res1 = 0 ;
46536 PyObject *swig_obj[1] ;
46537
46538 if (!args) SWIG_fail;
46539 swig_obj[0] = args;
46540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46541 if (!SWIG_IsOK(res1)) {
46542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46543 }
46544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46545 {
46546 PyThreadState* __tstate = wxPyBeginAllowThreads();
46547 (arg1)->DetachSizer();
46548 wxPyEndAllowThreads(__tstate);
46549 if (PyErr_Occurred()) SWIG_fail;
46550 }
46551 resultobj = SWIG_Py_Void();
46552 return resultobj;
46553 fail:
46554 return NULL;
46555 }
46556
46557
46558 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46559 PyObject *resultobj = 0;
46560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46561 wxSize result;
46562 void *argp1 = 0 ;
46563 int res1 = 0 ;
46564 PyObject *swig_obj[1] ;
46565
46566 if (!args) SWIG_fail;
46567 swig_obj[0] = args;
46568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46569 if (!SWIG_IsOK(res1)) {
46570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46571 }
46572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46573 {
46574 PyThreadState* __tstate = wxPyBeginAllowThreads();
46575 result = (arg1)->GetSize();
46576 wxPyEndAllowThreads(__tstate);
46577 if (PyErr_Occurred()) SWIG_fail;
46578 }
46579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46580 return resultobj;
46581 fail:
46582 return NULL;
46583 }
46584
46585
46586 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46587 PyObject *resultobj = 0;
46588 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46589 wxSize result;
46590 void *argp1 = 0 ;
46591 int res1 = 0 ;
46592 PyObject *swig_obj[1] ;
46593
46594 if (!args) SWIG_fail;
46595 swig_obj[0] = args;
46596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46597 if (!SWIG_IsOK(res1)) {
46598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46599 }
46600 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46601 {
46602 PyThreadState* __tstate = wxPyBeginAllowThreads();
46603 result = (arg1)->CalcMin();
46604 wxPyEndAllowThreads(__tstate);
46605 if (PyErr_Occurred()) SWIG_fail;
46606 }
46607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46608 return resultobj;
46609 fail:
46610 return NULL;
46611 }
46612
46613
46614 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46615 PyObject *resultobj = 0;
46616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46617 wxPoint *arg2 = 0 ;
46618 wxSize *arg3 = 0 ;
46619 void *argp1 = 0 ;
46620 int res1 = 0 ;
46621 wxPoint temp2 ;
46622 wxSize temp3 ;
46623 PyObject * obj0 = 0 ;
46624 PyObject * obj1 = 0 ;
46625 PyObject * obj2 = 0 ;
46626 char * kwnames[] = {
46627 (char *) "self",(char *) "pos",(char *) "size", NULL
46628 };
46629
46630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46632 if (!SWIG_IsOK(res1)) {
46633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46634 }
46635 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46636 {
46637 arg2 = &temp2;
46638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46639 }
46640 {
46641 arg3 = &temp3;
46642 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46643 }
46644 {
46645 PyThreadState* __tstate = wxPyBeginAllowThreads();
46646 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46647 wxPyEndAllowThreads(__tstate);
46648 if (PyErr_Occurred()) SWIG_fail;
46649 }
46650 resultobj = SWIG_Py_Void();
46651 return resultobj;
46652 fail:
46653 return NULL;
46654 }
46655
46656
46657 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46658 PyObject *resultobj = 0;
46659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46660 wxSize result;
46661 void *argp1 = 0 ;
46662 int res1 = 0 ;
46663 PyObject *swig_obj[1] ;
46664
46665 if (!args) SWIG_fail;
46666 swig_obj[0] = args;
46667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46670 }
46671 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46672 {
46673 PyThreadState* __tstate = wxPyBeginAllowThreads();
46674 result = (arg1)->GetMinSize();
46675 wxPyEndAllowThreads(__tstate);
46676 if (PyErr_Occurred()) SWIG_fail;
46677 }
46678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46679 return resultobj;
46680 fail:
46681 return NULL;
46682 }
46683
46684
46685 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46686 PyObject *resultobj = 0;
46687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46688 wxSize result;
46689 void *argp1 = 0 ;
46690 int res1 = 0 ;
46691 PyObject *swig_obj[1] ;
46692
46693 if (!args) SWIG_fail;
46694 swig_obj[0] = args;
46695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46696 if (!SWIG_IsOK(res1)) {
46697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46698 }
46699 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46700 {
46701 PyThreadState* __tstate = wxPyBeginAllowThreads();
46702 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46703 wxPyEndAllowThreads(__tstate);
46704 if (PyErr_Occurred()) SWIG_fail;
46705 }
46706 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46707 return resultobj;
46708 fail:
46709 return NULL;
46710 }
46711
46712
46713 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46714 PyObject *resultobj = 0;
46715 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46716 int arg2 ;
46717 int arg3 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 int val2 ;
46721 int ecode2 = 0 ;
46722 int val3 ;
46723 int ecode3 = 0 ;
46724 PyObject * obj0 = 0 ;
46725 PyObject * obj1 = 0 ;
46726 PyObject * obj2 = 0 ;
46727 char * kwnames[] = {
46728 (char *) "self",(char *) "x",(char *) "y", NULL
46729 };
46730
46731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46733 if (!SWIG_IsOK(res1)) {
46734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46735 }
46736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46737 ecode2 = SWIG_AsVal_int(obj1, &val2);
46738 if (!SWIG_IsOK(ecode2)) {
46739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46740 }
46741 arg2 = static_cast< int >(val2);
46742 ecode3 = SWIG_AsVal_int(obj2, &val3);
46743 if (!SWIG_IsOK(ecode3)) {
46744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46745 }
46746 arg3 = static_cast< int >(val3);
46747 {
46748 PyThreadState* __tstate = wxPyBeginAllowThreads();
46749 (arg1)->SetInitSize(arg2,arg3);
46750 wxPyEndAllowThreads(__tstate);
46751 if (PyErr_Occurred()) SWIG_fail;
46752 }
46753 resultobj = SWIG_Py_Void();
46754 return resultobj;
46755 fail:
46756 return NULL;
46757 }
46758
46759
46760 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46761 PyObject *resultobj = 0;
46762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46763 int arg2 ;
46764 int arg3 ;
46765 void *argp1 = 0 ;
46766 int res1 = 0 ;
46767 int val2 ;
46768 int ecode2 = 0 ;
46769 int val3 ;
46770 int ecode3 = 0 ;
46771 PyObject * obj0 = 0 ;
46772 PyObject * obj1 = 0 ;
46773 PyObject * obj2 = 0 ;
46774 char * kwnames[] = {
46775 (char *) "self",(char *) "width",(char *) "height", NULL
46776 };
46777
46778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46780 if (!SWIG_IsOK(res1)) {
46781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46782 }
46783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46784 ecode2 = SWIG_AsVal_int(obj1, &val2);
46785 if (!SWIG_IsOK(ecode2)) {
46786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46787 }
46788 arg2 = static_cast< int >(val2);
46789 ecode3 = SWIG_AsVal_int(obj2, &val3);
46790 if (!SWIG_IsOK(ecode3)) {
46791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46792 }
46793 arg3 = static_cast< int >(val3);
46794 {
46795 PyThreadState* __tstate = wxPyBeginAllowThreads();
46796 (arg1)->SetRatio(arg2,arg3);
46797 wxPyEndAllowThreads(__tstate);
46798 if (PyErr_Occurred()) SWIG_fail;
46799 }
46800 resultobj = SWIG_Py_Void();
46801 return resultobj;
46802 fail:
46803 return NULL;
46804 }
46805
46806
46807 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46808 PyObject *resultobj = 0;
46809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46810 wxSize *arg2 = 0 ;
46811 void *argp1 = 0 ;
46812 int res1 = 0 ;
46813 wxSize temp2 ;
46814 PyObject * obj0 = 0 ;
46815 PyObject * obj1 = 0 ;
46816 char * kwnames[] = {
46817 (char *) "self",(char *) "size", NULL
46818 };
46819
46820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46824 }
46825 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46826 {
46827 arg2 = &temp2;
46828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46829 }
46830 {
46831 PyThreadState* __tstate = wxPyBeginAllowThreads();
46832 (arg1)->SetRatio((wxSize const &)*arg2);
46833 wxPyEndAllowThreads(__tstate);
46834 if (PyErr_Occurred()) SWIG_fail;
46835 }
46836 resultobj = SWIG_Py_Void();
46837 return resultobj;
46838 fail:
46839 return NULL;
46840 }
46841
46842
46843 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46844 PyObject *resultobj = 0;
46845 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46846 float arg2 ;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 float val2 ;
46850 int ecode2 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 char * kwnames[] = {
46854 (char *) "self",(char *) "ratio", NULL
46855 };
46856
46857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46859 if (!SWIG_IsOK(res1)) {
46860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46861 }
46862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46863 ecode2 = SWIG_AsVal_float(obj1, &val2);
46864 if (!SWIG_IsOK(ecode2)) {
46865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46866 }
46867 arg2 = static_cast< float >(val2);
46868 {
46869 PyThreadState* __tstate = wxPyBeginAllowThreads();
46870 (arg1)->SetRatio(arg2);
46871 wxPyEndAllowThreads(__tstate);
46872 if (PyErr_Occurred()) SWIG_fail;
46873 }
46874 resultobj = SWIG_Py_Void();
46875 return resultobj;
46876 fail:
46877 return NULL;
46878 }
46879
46880
46881 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46882 PyObject *resultobj = 0;
46883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46884 float result;
46885 void *argp1 = 0 ;
46886 int res1 = 0 ;
46887 PyObject *swig_obj[1] ;
46888
46889 if (!args) SWIG_fail;
46890 swig_obj[0] = args;
46891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46892 if (!SWIG_IsOK(res1)) {
46893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46894 }
46895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 result = (float)(arg1)->GetRatio();
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 resultobj = SWIG_From_float(static_cast< float >(result));
46903 return resultobj;
46904 fail:
46905 return NULL;
46906 }
46907
46908
46909 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46910 PyObject *resultobj = 0;
46911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46912 wxRect result;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 PyObject *swig_obj[1] ;
46916
46917 if (!args) SWIG_fail;
46918 swig_obj[0] = args;
46919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46920 if (!SWIG_IsOK(res1)) {
46921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46922 }
46923 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46924 {
46925 PyThreadState* __tstate = wxPyBeginAllowThreads();
46926 result = (arg1)->GetRect();
46927 wxPyEndAllowThreads(__tstate);
46928 if (PyErr_Occurred()) SWIG_fail;
46929 }
46930 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46931 return resultobj;
46932 fail:
46933 return NULL;
46934 }
46935
46936
46937 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46938 PyObject *resultobj = 0;
46939 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46940 bool result;
46941 void *argp1 = 0 ;
46942 int res1 = 0 ;
46943 PyObject *swig_obj[1] ;
46944
46945 if (!args) SWIG_fail;
46946 swig_obj[0] = args;
46947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46948 if (!SWIG_IsOK(res1)) {
46949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46950 }
46951 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46952 {
46953 PyThreadState* __tstate = wxPyBeginAllowThreads();
46954 result = (bool)(arg1)->IsWindow();
46955 wxPyEndAllowThreads(__tstate);
46956 if (PyErr_Occurred()) SWIG_fail;
46957 }
46958 {
46959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46960 }
46961 return resultobj;
46962 fail:
46963 return NULL;
46964 }
46965
46966
46967 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46968 PyObject *resultobj = 0;
46969 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46970 bool result;
46971 void *argp1 = 0 ;
46972 int res1 = 0 ;
46973 PyObject *swig_obj[1] ;
46974
46975 if (!args) SWIG_fail;
46976 swig_obj[0] = args;
46977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46978 if (!SWIG_IsOK(res1)) {
46979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46980 }
46981 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46982 {
46983 PyThreadState* __tstate = wxPyBeginAllowThreads();
46984 result = (bool)(arg1)->IsSizer();
46985 wxPyEndAllowThreads(__tstate);
46986 if (PyErr_Occurred()) SWIG_fail;
46987 }
46988 {
46989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46990 }
46991 return resultobj;
46992 fail:
46993 return NULL;
46994 }
46995
46996
46997 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46998 PyObject *resultobj = 0;
46999 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47000 bool result;
47001 void *argp1 = 0 ;
47002 int res1 = 0 ;
47003 PyObject *swig_obj[1] ;
47004
47005 if (!args) SWIG_fail;
47006 swig_obj[0] = args;
47007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47008 if (!SWIG_IsOK(res1)) {
47009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47010 }
47011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 result = (bool)(arg1)->IsSpacer();
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 {
47019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47020 }
47021 return resultobj;
47022 fail:
47023 return NULL;
47024 }
47025
47026
47027 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47028 PyObject *resultobj = 0;
47029 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47030 int arg2 ;
47031 void *argp1 = 0 ;
47032 int res1 = 0 ;
47033 int val2 ;
47034 int ecode2 = 0 ;
47035 PyObject * obj0 = 0 ;
47036 PyObject * obj1 = 0 ;
47037 char * kwnames[] = {
47038 (char *) "self",(char *) "proportion", NULL
47039 };
47040
47041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
47042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47043 if (!SWIG_IsOK(res1)) {
47044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47045 }
47046 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47047 ecode2 = SWIG_AsVal_int(obj1, &val2);
47048 if (!SWIG_IsOK(ecode2)) {
47049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
47050 }
47051 arg2 = static_cast< int >(val2);
47052 {
47053 PyThreadState* __tstate = wxPyBeginAllowThreads();
47054 (arg1)->SetProportion(arg2);
47055 wxPyEndAllowThreads(__tstate);
47056 if (PyErr_Occurred()) SWIG_fail;
47057 }
47058 resultobj = SWIG_Py_Void();
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47066 PyObject *resultobj = 0;
47067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47068 int result;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 PyObject *swig_obj[1] ;
47072
47073 if (!args) SWIG_fail;
47074 swig_obj[0] = args;
47075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47076 if (!SWIG_IsOK(res1)) {
47077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47078 }
47079 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 result = (int)(arg1)->GetProportion();
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 resultobj = SWIG_From_int(static_cast< int >(result));
47087 return resultobj;
47088 fail:
47089 return NULL;
47090 }
47091
47092
47093 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47096 int arg2 ;
47097 void *argp1 = 0 ;
47098 int res1 = 0 ;
47099 int val2 ;
47100 int ecode2 = 0 ;
47101 PyObject * obj0 = 0 ;
47102 PyObject * obj1 = 0 ;
47103 char * kwnames[] = {
47104 (char *) "self",(char *) "flag", NULL
47105 };
47106
47107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
47108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47111 }
47112 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47113 ecode2 = SWIG_AsVal_int(obj1, &val2);
47114 if (!SWIG_IsOK(ecode2)) {
47115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
47116 }
47117 arg2 = static_cast< int >(val2);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 (arg1)->SetFlag(arg2);
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 resultobj = SWIG_Py_Void();
47125 return resultobj;
47126 fail:
47127 return NULL;
47128 }
47129
47130
47131 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47132 PyObject *resultobj = 0;
47133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47134 int result;
47135 void *argp1 = 0 ;
47136 int res1 = 0 ;
47137 PyObject *swig_obj[1] ;
47138
47139 if (!args) SWIG_fail;
47140 swig_obj[0] = args;
47141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47142 if (!SWIG_IsOK(res1)) {
47143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47144 }
47145 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 result = (int)(arg1)->GetFlag();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_From_int(static_cast< int >(result));
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47160 PyObject *resultobj = 0;
47161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47162 int arg2 ;
47163 void *argp1 = 0 ;
47164 int res1 = 0 ;
47165 int val2 ;
47166 int ecode2 = 0 ;
47167 PyObject * obj0 = 0 ;
47168 PyObject * obj1 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "border", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47177 }
47178 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47179 ecode2 = SWIG_AsVal_int(obj1, &val2);
47180 if (!SWIG_IsOK(ecode2)) {
47181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
47182 }
47183 arg2 = static_cast< int >(val2);
47184 {
47185 PyThreadState* __tstate = wxPyBeginAllowThreads();
47186 (arg1)->SetBorder(arg2);
47187 wxPyEndAllowThreads(__tstate);
47188 if (PyErr_Occurred()) SWIG_fail;
47189 }
47190 resultobj = SWIG_Py_Void();
47191 return resultobj;
47192 fail:
47193 return NULL;
47194 }
47195
47196
47197 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47198 PyObject *resultobj = 0;
47199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47200 int result;
47201 void *argp1 = 0 ;
47202 int res1 = 0 ;
47203 PyObject *swig_obj[1] ;
47204
47205 if (!args) SWIG_fail;
47206 swig_obj[0] = args;
47207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47208 if (!SWIG_IsOK(res1)) {
47209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47210 }
47211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47212 {
47213 PyThreadState* __tstate = wxPyBeginAllowThreads();
47214 result = (int)(arg1)->GetBorder();
47215 wxPyEndAllowThreads(__tstate);
47216 if (PyErr_Occurred()) SWIG_fail;
47217 }
47218 resultobj = SWIG_From_int(static_cast< int >(result));
47219 return resultobj;
47220 fail:
47221 return NULL;
47222 }
47223
47224
47225 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47226 PyObject *resultobj = 0;
47227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47228 wxWindow *result = 0 ;
47229 void *argp1 = 0 ;
47230 int res1 = 0 ;
47231 PyObject *swig_obj[1] ;
47232
47233 if (!args) SWIG_fail;
47234 swig_obj[0] = args;
47235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47236 if (!SWIG_IsOK(res1)) {
47237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47238 }
47239 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47240 {
47241 PyThreadState* __tstate = wxPyBeginAllowThreads();
47242 result = (wxWindow *)(arg1)->GetWindow();
47243 wxPyEndAllowThreads(__tstate);
47244 if (PyErr_Occurred()) SWIG_fail;
47245 }
47246 {
47247 resultobj = wxPyMake_wxObject(result, 0);
47248 }
47249 return resultobj;
47250 fail:
47251 return NULL;
47252 }
47253
47254
47255 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47256 PyObject *resultobj = 0;
47257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47258 wxWindow *arg2 = (wxWindow *) 0 ;
47259 void *argp1 = 0 ;
47260 int res1 = 0 ;
47261 void *argp2 = 0 ;
47262 int res2 = 0 ;
47263 PyObject * obj0 = 0 ;
47264 PyObject * obj1 = 0 ;
47265 char * kwnames[] = {
47266 (char *) "self",(char *) "window", NULL
47267 };
47268
47269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47271 if (!SWIG_IsOK(res1)) {
47272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47273 }
47274 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47276 if (!SWIG_IsOK(res2)) {
47277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47278 }
47279 arg2 = reinterpret_cast< wxWindow * >(argp2);
47280 {
47281 PyThreadState* __tstate = wxPyBeginAllowThreads();
47282 (arg1)->SetWindow(arg2);
47283 wxPyEndAllowThreads(__tstate);
47284 if (PyErr_Occurred()) SWIG_fail;
47285 }
47286 resultobj = SWIG_Py_Void();
47287 return resultobj;
47288 fail:
47289 return NULL;
47290 }
47291
47292
47293 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47294 PyObject *resultobj = 0;
47295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47296 wxSizer *result = 0 ;
47297 void *argp1 = 0 ;
47298 int res1 = 0 ;
47299 PyObject *swig_obj[1] ;
47300
47301 if (!args) SWIG_fail;
47302 swig_obj[0] = args;
47303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47304 if (!SWIG_IsOK(res1)) {
47305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47306 }
47307 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47308 {
47309 PyThreadState* __tstate = wxPyBeginAllowThreads();
47310 result = (wxSizer *)(arg1)->GetSizer();
47311 wxPyEndAllowThreads(__tstate);
47312 if (PyErr_Occurred()) SWIG_fail;
47313 }
47314 {
47315 resultobj = wxPyMake_wxObject(result, (bool)0);
47316 }
47317 return resultobj;
47318 fail:
47319 return NULL;
47320 }
47321
47322
47323 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47324 PyObject *resultobj = 0;
47325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47326 wxSizer *arg2 = (wxSizer *) 0 ;
47327 void *argp1 = 0 ;
47328 int res1 = 0 ;
47329 int res2 = 0 ;
47330 PyObject * obj0 = 0 ;
47331 PyObject * obj1 = 0 ;
47332 char * kwnames[] = {
47333 (char *) "self",(char *) "sizer", NULL
47334 };
47335
47336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47338 if (!SWIG_IsOK(res1)) {
47339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47340 }
47341 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47342 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47343 if (!SWIG_IsOK(res2)) {
47344 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47345 }
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 (arg1)->SetSizer(arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 resultobj = SWIG_Py_Void();
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47362 wxSize *result = 0 ;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47372 }
47373 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 {
47377 wxSize const &_result_ref = (arg1)->GetSpacer();
47378 result = (wxSize *) &_result_ref;
47379 }
47380 wxPyEndAllowThreads(__tstate);
47381 if (PyErr_Occurred()) SWIG_fail;
47382 }
47383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
47384 return resultobj;
47385 fail:
47386 return NULL;
47387 }
47388
47389
47390 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47391 PyObject *resultobj = 0;
47392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47393 wxSize *arg2 = 0 ;
47394 void *argp1 = 0 ;
47395 int res1 = 0 ;
47396 wxSize temp2 ;
47397 PyObject * obj0 = 0 ;
47398 PyObject * obj1 = 0 ;
47399 char * kwnames[] = {
47400 (char *) "self",(char *) "size", NULL
47401 };
47402
47403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
47404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47405 if (!SWIG_IsOK(res1)) {
47406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47407 }
47408 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47409 {
47410 arg2 = &temp2;
47411 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47412 }
47413 {
47414 PyThreadState* __tstate = wxPyBeginAllowThreads();
47415 (arg1)->SetSpacer((wxSize const &)*arg2);
47416 wxPyEndAllowThreads(__tstate);
47417 if (PyErr_Occurred()) SWIG_fail;
47418 }
47419 resultobj = SWIG_Py_Void();
47420 return resultobj;
47421 fail:
47422 return NULL;
47423 }
47424
47425
47426 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47427 PyObject *resultobj = 0;
47428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47429 bool arg2 ;
47430 void *argp1 = 0 ;
47431 int res1 = 0 ;
47432 bool val2 ;
47433 int ecode2 = 0 ;
47434 PyObject * obj0 = 0 ;
47435 PyObject * obj1 = 0 ;
47436 char * kwnames[] = {
47437 (char *) "self",(char *) "show", NULL
47438 };
47439
47440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
47441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47444 }
47445 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47447 if (!SWIG_IsOK(ecode2)) {
47448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
47449 }
47450 arg2 = static_cast< bool >(val2);
47451 {
47452 PyThreadState* __tstate = wxPyBeginAllowThreads();
47453 (arg1)->Show(arg2);
47454 wxPyEndAllowThreads(__tstate);
47455 if (PyErr_Occurred()) SWIG_fail;
47456 }
47457 resultobj = SWIG_Py_Void();
47458 return resultobj;
47459 fail:
47460 return NULL;
47461 }
47462
47463
47464 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47465 PyObject *resultobj = 0;
47466 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47467 bool result;
47468 void *argp1 = 0 ;
47469 int res1 = 0 ;
47470 PyObject *swig_obj[1] ;
47471
47472 if (!args) SWIG_fail;
47473 swig_obj[0] = args;
47474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47475 if (!SWIG_IsOK(res1)) {
47476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47477 }
47478 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47479 {
47480 PyThreadState* __tstate = wxPyBeginAllowThreads();
47481 result = (bool)(arg1)->IsShown();
47482 wxPyEndAllowThreads(__tstate);
47483 if (PyErr_Occurred()) SWIG_fail;
47484 }
47485 {
47486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47487 }
47488 return resultobj;
47489 fail:
47490 return NULL;
47491 }
47492
47493
47494 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47495 PyObject *resultobj = 0;
47496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47497 wxPoint result;
47498 void *argp1 = 0 ;
47499 int res1 = 0 ;
47500 PyObject *swig_obj[1] ;
47501
47502 if (!args) SWIG_fail;
47503 swig_obj[0] = args;
47504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47505 if (!SWIG_IsOK(res1)) {
47506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47507 }
47508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47509 {
47510 PyThreadState* __tstate = wxPyBeginAllowThreads();
47511 result = (arg1)->GetPosition();
47512 wxPyEndAllowThreads(__tstate);
47513 if (PyErr_Occurred()) SWIG_fail;
47514 }
47515 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47516 return resultobj;
47517 fail:
47518 return NULL;
47519 }
47520
47521
47522 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47523 PyObject *resultobj = 0;
47524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47525 PyObject *result = 0 ;
47526 void *argp1 = 0 ;
47527 int res1 = 0 ;
47528 PyObject *swig_obj[1] ;
47529
47530 if (!args) SWIG_fail;
47531 swig_obj[0] = args;
47532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47533 if (!SWIG_IsOK(res1)) {
47534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47535 }
47536 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47537 {
47538 PyThreadState* __tstate = wxPyBeginAllowThreads();
47539 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47540 wxPyEndAllowThreads(__tstate);
47541 if (PyErr_Occurred()) SWIG_fail;
47542 }
47543 resultobj = result;
47544 return resultobj;
47545 fail:
47546 return NULL;
47547 }
47548
47549
47550 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47551 PyObject *resultobj = 0;
47552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47553 PyObject *arg2 = (PyObject *) 0 ;
47554 void *argp1 = 0 ;
47555 int res1 = 0 ;
47556 PyObject * obj0 = 0 ;
47557 PyObject * obj1 = 0 ;
47558 char * kwnames[] = {
47559 (char *) "self",(char *) "userData", NULL
47560 };
47561
47562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47564 if (!SWIG_IsOK(res1)) {
47565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47566 }
47567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47568 arg2 = obj1;
47569 {
47570 PyThreadState* __tstate = wxPyBeginAllowThreads();
47571 wxSizerItem_SetUserData(arg1,arg2);
47572 wxPyEndAllowThreads(__tstate);
47573 if (PyErr_Occurred()) SWIG_fail;
47574 }
47575 resultobj = SWIG_Py_Void();
47576 return resultobj;
47577 fail:
47578 return NULL;
47579 }
47580
47581
47582 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47583 PyObject *obj;
47584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47585 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47586 return SWIG_Py_Void();
47587 }
47588
47589 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47590 return SWIG_Python_InitShadowInstance(args);
47591 }
47592
47593 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47594 PyObject *resultobj = 0;
47595 wxSizer *arg1 = (wxSizer *) 0 ;
47596 void *argp1 = 0 ;
47597 int res1 = 0 ;
47598 PyObject *swig_obj[1] ;
47599
47600 if (!args) SWIG_fail;
47601 swig_obj[0] = args;
47602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47603 if (!SWIG_IsOK(res1)) {
47604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47605 }
47606 arg1 = reinterpret_cast< wxSizer * >(argp1);
47607 {
47608 PyThreadState* __tstate = wxPyBeginAllowThreads();
47609 delete arg1;
47610
47611 wxPyEndAllowThreads(__tstate);
47612 if (PyErr_Occurred()) SWIG_fail;
47613 }
47614 resultobj = SWIG_Py_Void();
47615 return resultobj;
47616 fail:
47617 return NULL;
47618 }
47619
47620
47621 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47622 PyObject *resultobj = 0;
47623 wxSizer *arg1 = (wxSizer *) 0 ;
47624 PyObject *arg2 = (PyObject *) 0 ;
47625 void *argp1 = 0 ;
47626 int res1 = 0 ;
47627 PyObject * obj0 = 0 ;
47628 PyObject * obj1 = 0 ;
47629 char * kwnames[] = {
47630 (char *) "self",(char *) "_self", NULL
47631 };
47632
47633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47635 if (!SWIG_IsOK(res1)) {
47636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47637 }
47638 arg1 = reinterpret_cast< wxSizer * >(argp1);
47639 arg2 = obj1;
47640 {
47641 PyThreadState* __tstate = wxPyBeginAllowThreads();
47642 wxSizer__setOORInfo(arg1,arg2);
47643 wxPyEndAllowThreads(__tstate);
47644 if (PyErr_Occurred()) SWIG_fail;
47645 }
47646 resultobj = SWIG_Py_Void();
47647 return resultobj;
47648 fail:
47649 return NULL;
47650 }
47651
47652
47653 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47654 PyObject *resultobj = 0;
47655 wxSizer *arg1 = (wxSizer *) 0 ;
47656 PyObject *arg2 = (PyObject *) 0 ;
47657 int arg3 = (int) 0 ;
47658 int arg4 = (int) 0 ;
47659 int arg5 = (int) 0 ;
47660 PyObject *arg6 = (PyObject *) NULL ;
47661 wxSizerItem *result = 0 ;
47662 void *argp1 = 0 ;
47663 int res1 = 0 ;
47664 int val3 ;
47665 int ecode3 = 0 ;
47666 int val4 ;
47667 int ecode4 = 0 ;
47668 int val5 ;
47669 int ecode5 = 0 ;
47670 PyObject * obj0 = 0 ;
47671 PyObject * obj1 = 0 ;
47672 PyObject * obj2 = 0 ;
47673 PyObject * obj3 = 0 ;
47674 PyObject * obj4 = 0 ;
47675 PyObject * obj5 = 0 ;
47676 char * kwnames[] = {
47677 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47678 };
47679
47680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47682 if (!SWIG_IsOK(res1)) {
47683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47684 }
47685 arg1 = reinterpret_cast< wxSizer * >(argp1);
47686 arg2 = obj1;
47687 if (obj2) {
47688 ecode3 = SWIG_AsVal_int(obj2, &val3);
47689 if (!SWIG_IsOK(ecode3)) {
47690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47691 }
47692 arg3 = static_cast< int >(val3);
47693 }
47694 if (obj3) {
47695 ecode4 = SWIG_AsVal_int(obj3, &val4);
47696 if (!SWIG_IsOK(ecode4)) {
47697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47698 }
47699 arg4 = static_cast< int >(val4);
47700 }
47701 if (obj4) {
47702 ecode5 = SWIG_AsVal_int(obj4, &val5);
47703 if (!SWIG_IsOK(ecode5)) {
47704 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47705 }
47706 arg5 = static_cast< int >(val5);
47707 }
47708 if (obj5) {
47709 arg6 = obj5;
47710 }
47711 {
47712 PyThreadState* __tstate = wxPyBeginAllowThreads();
47713 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47714 wxPyEndAllowThreads(__tstate);
47715 if (PyErr_Occurred()) SWIG_fail;
47716 }
47717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47718 return resultobj;
47719 fail:
47720 return NULL;
47721 }
47722
47723
47724 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47725 PyObject *resultobj = 0;
47726 wxSizer *arg1 = (wxSizer *) 0 ;
47727 int arg2 ;
47728 PyObject *arg3 = (PyObject *) 0 ;
47729 int arg4 = (int) 0 ;
47730 int arg5 = (int) 0 ;
47731 int arg6 = (int) 0 ;
47732 PyObject *arg7 = (PyObject *) NULL ;
47733 wxSizerItem *result = 0 ;
47734 void *argp1 = 0 ;
47735 int res1 = 0 ;
47736 int val2 ;
47737 int ecode2 = 0 ;
47738 int val4 ;
47739 int ecode4 = 0 ;
47740 int val5 ;
47741 int ecode5 = 0 ;
47742 int val6 ;
47743 int ecode6 = 0 ;
47744 PyObject * obj0 = 0 ;
47745 PyObject * obj1 = 0 ;
47746 PyObject * obj2 = 0 ;
47747 PyObject * obj3 = 0 ;
47748 PyObject * obj4 = 0 ;
47749 PyObject * obj5 = 0 ;
47750 PyObject * obj6 = 0 ;
47751 char * kwnames[] = {
47752 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47753 };
47754
47755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47757 if (!SWIG_IsOK(res1)) {
47758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47759 }
47760 arg1 = reinterpret_cast< wxSizer * >(argp1);
47761 ecode2 = SWIG_AsVal_int(obj1, &val2);
47762 if (!SWIG_IsOK(ecode2)) {
47763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47764 }
47765 arg2 = static_cast< int >(val2);
47766 arg3 = obj2;
47767 if (obj3) {
47768 ecode4 = SWIG_AsVal_int(obj3, &val4);
47769 if (!SWIG_IsOK(ecode4)) {
47770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47771 }
47772 arg4 = static_cast< int >(val4);
47773 }
47774 if (obj4) {
47775 ecode5 = SWIG_AsVal_int(obj4, &val5);
47776 if (!SWIG_IsOK(ecode5)) {
47777 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47778 }
47779 arg5 = static_cast< int >(val5);
47780 }
47781 if (obj5) {
47782 ecode6 = SWIG_AsVal_int(obj5, &val6);
47783 if (!SWIG_IsOK(ecode6)) {
47784 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47785 }
47786 arg6 = static_cast< int >(val6);
47787 }
47788 if (obj6) {
47789 arg7 = obj6;
47790 }
47791 {
47792 PyThreadState* __tstate = wxPyBeginAllowThreads();
47793 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47794 wxPyEndAllowThreads(__tstate);
47795 if (PyErr_Occurred()) SWIG_fail;
47796 }
47797 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47798 return resultobj;
47799 fail:
47800 return NULL;
47801 }
47802
47803
47804 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47805 PyObject *resultobj = 0;
47806 wxSizer *arg1 = (wxSizer *) 0 ;
47807 PyObject *arg2 = (PyObject *) 0 ;
47808 int arg3 = (int) 0 ;
47809 int arg4 = (int) 0 ;
47810 int arg5 = (int) 0 ;
47811 PyObject *arg6 = (PyObject *) NULL ;
47812 wxSizerItem *result = 0 ;
47813 void *argp1 = 0 ;
47814 int res1 = 0 ;
47815 int val3 ;
47816 int ecode3 = 0 ;
47817 int val4 ;
47818 int ecode4 = 0 ;
47819 int val5 ;
47820 int ecode5 = 0 ;
47821 PyObject * obj0 = 0 ;
47822 PyObject * obj1 = 0 ;
47823 PyObject * obj2 = 0 ;
47824 PyObject * obj3 = 0 ;
47825 PyObject * obj4 = 0 ;
47826 PyObject * obj5 = 0 ;
47827 char * kwnames[] = {
47828 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47829 };
47830
47831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47833 if (!SWIG_IsOK(res1)) {
47834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47835 }
47836 arg1 = reinterpret_cast< wxSizer * >(argp1);
47837 arg2 = obj1;
47838 if (obj2) {
47839 ecode3 = SWIG_AsVal_int(obj2, &val3);
47840 if (!SWIG_IsOK(ecode3)) {
47841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47842 }
47843 arg3 = static_cast< int >(val3);
47844 }
47845 if (obj3) {
47846 ecode4 = SWIG_AsVal_int(obj3, &val4);
47847 if (!SWIG_IsOK(ecode4)) {
47848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47849 }
47850 arg4 = static_cast< int >(val4);
47851 }
47852 if (obj4) {
47853 ecode5 = SWIG_AsVal_int(obj4, &val5);
47854 if (!SWIG_IsOK(ecode5)) {
47855 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47856 }
47857 arg5 = static_cast< int >(val5);
47858 }
47859 if (obj5) {
47860 arg6 = obj5;
47861 }
47862 {
47863 PyThreadState* __tstate = wxPyBeginAllowThreads();
47864 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47865 wxPyEndAllowThreads(__tstate);
47866 if (PyErr_Occurred()) SWIG_fail;
47867 }
47868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47869 return resultobj;
47870 fail:
47871 return NULL;
47872 }
47873
47874
47875 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47876 PyObject *resultobj = 0;
47877 wxSizer *arg1 = (wxSizer *) 0 ;
47878 PyObject *arg2 = (PyObject *) 0 ;
47879 bool result;
47880 void *argp1 = 0 ;
47881 int res1 = 0 ;
47882 PyObject * obj0 = 0 ;
47883 PyObject * obj1 = 0 ;
47884 char * kwnames[] = {
47885 (char *) "self",(char *) "item", NULL
47886 };
47887
47888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47890 if (!SWIG_IsOK(res1)) {
47891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47892 }
47893 arg1 = reinterpret_cast< wxSizer * >(argp1);
47894 arg2 = obj1;
47895 {
47896 PyThreadState* __tstate = wxPyBeginAllowThreads();
47897 result = (bool)wxSizer_Remove(arg1,arg2);
47898 wxPyEndAllowThreads(__tstate);
47899 if (PyErr_Occurred()) SWIG_fail;
47900 }
47901 {
47902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47903 }
47904 return resultobj;
47905 fail:
47906 return NULL;
47907 }
47908
47909
47910 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47911 PyObject *resultobj = 0;
47912 wxSizer *arg1 = (wxSizer *) 0 ;
47913 PyObject *arg2 = (PyObject *) 0 ;
47914 bool result;
47915 void *argp1 = 0 ;
47916 int res1 = 0 ;
47917 PyObject * obj0 = 0 ;
47918 PyObject * obj1 = 0 ;
47919 char * kwnames[] = {
47920 (char *) "self",(char *) "item", NULL
47921 };
47922
47923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47925 if (!SWIG_IsOK(res1)) {
47926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47927 }
47928 arg1 = reinterpret_cast< wxSizer * >(argp1);
47929 arg2 = obj1;
47930 {
47931 PyThreadState* __tstate = wxPyBeginAllowThreads();
47932 result = (bool)wxSizer_Detach(arg1,arg2);
47933 wxPyEndAllowThreads(__tstate);
47934 if (PyErr_Occurred()) SWIG_fail;
47935 }
47936 {
47937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47938 }
47939 return resultobj;
47940 fail:
47941 return NULL;
47942 }
47943
47944
47945 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47946 PyObject *resultobj = 0;
47947 wxSizer *arg1 = (wxSizer *) 0 ;
47948 PyObject *arg2 = (PyObject *) 0 ;
47949 wxSizerItem *result = 0 ;
47950 void *argp1 = 0 ;
47951 int res1 = 0 ;
47952 PyObject * obj0 = 0 ;
47953 PyObject * obj1 = 0 ;
47954 char * kwnames[] = {
47955 (char *) "self",(char *) "item", NULL
47956 };
47957
47958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47960 if (!SWIG_IsOK(res1)) {
47961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47962 }
47963 arg1 = reinterpret_cast< wxSizer * >(argp1);
47964 arg2 = obj1;
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47979 PyObject *resultobj = 0;
47980 wxSizer *arg1 = (wxSizer *) 0 ;
47981 PyObject *arg2 = (PyObject *) 0 ;
47982 wxSize *arg3 = 0 ;
47983 void *argp1 = 0 ;
47984 int res1 = 0 ;
47985 wxSize temp3 ;
47986 PyObject * obj0 = 0 ;
47987 PyObject * obj1 = 0 ;
47988 PyObject * obj2 = 0 ;
47989 char * kwnames[] = {
47990 (char *) "self",(char *) "item",(char *) "size", NULL
47991 };
47992
47993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47995 if (!SWIG_IsOK(res1)) {
47996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47997 }
47998 arg1 = reinterpret_cast< wxSizer * >(argp1);
47999 arg2 = obj1;
48000 {
48001 arg3 = &temp3;
48002 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48003 }
48004 {
48005 PyThreadState* __tstate = wxPyBeginAllowThreads();
48006 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
48007 wxPyEndAllowThreads(__tstate);
48008 if (PyErr_Occurred()) SWIG_fail;
48009 }
48010 resultobj = SWIG_Py_Void();
48011 return resultobj;
48012 fail:
48013 return NULL;
48014 }
48015
48016
48017 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48018 PyObject *resultobj = 0;
48019 wxSizer *arg1 = (wxSizer *) 0 ;
48020 wxWindow *arg2 = (wxWindow *) 0 ;
48021 wxWindow *arg3 = (wxWindow *) 0 ;
48022 bool arg4 = (bool) false ;
48023 bool result;
48024 void *argp1 = 0 ;
48025 int res1 = 0 ;
48026 void *argp2 = 0 ;
48027 int res2 = 0 ;
48028 void *argp3 = 0 ;
48029 int res3 = 0 ;
48030 bool val4 ;
48031 int ecode4 = 0 ;
48032 PyObject * obj0 = 0 ;
48033 PyObject * obj1 = 0 ;
48034 PyObject * obj2 = 0 ;
48035 PyObject * obj3 = 0 ;
48036 char * kwnames[] = {
48037 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
48038 };
48039
48040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48042 if (!SWIG_IsOK(res1)) {
48043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
48044 }
48045 arg1 = reinterpret_cast< wxSizer * >(argp1);
48046 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48047 if (!SWIG_IsOK(res2)) {
48048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
48049 }
48050 arg2 = reinterpret_cast< wxWindow * >(argp2);
48051 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
48052 if (!SWIG_IsOK(res3)) {
48053 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
48054 }
48055 arg3 = reinterpret_cast< wxWindow * >(argp3);
48056 if (obj3) {
48057 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48058 if (!SWIG_IsOK(ecode4)) {
48059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
48060 }
48061 arg4 = static_cast< bool >(val4);
48062 }
48063 {
48064 PyThreadState* __tstate = wxPyBeginAllowThreads();
48065 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48066 wxPyEndAllowThreads(__tstate);
48067 if (PyErr_Occurred()) SWIG_fail;
48068 }
48069 {
48070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48071 }
48072 return resultobj;
48073 fail:
48074 return NULL;
48075 }
48076
48077
48078 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48079 PyObject *resultobj = 0;
48080 wxSizer *arg1 = (wxSizer *) 0 ;
48081 wxSizer *arg2 = (wxSizer *) 0 ;
48082 wxSizer *arg3 = (wxSizer *) 0 ;
48083 bool arg4 = (bool) false ;
48084 bool result;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 void *argp2 = 0 ;
48088 int res2 = 0 ;
48089 void *argp3 = 0 ;
48090 int res3 = 0 ;
48091 bool val4 ;
48092 int ecode4 = 0 ;
48093 PyObject * obj0 = 0 ;
48094 PyObject * obj1 = 0 ;
48095 PyObject * obj2 = 0 ;
48096 PyObject * obj3 = 0 ;
48097 char * kwnames[] = {
48098 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
48099 };
48100
48101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48103 if (!SWIG_IsOK(res1)) {
48104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48105 }
48106 arg1 = reinterpret_cast< wxSizer * >(argp1);
48107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
48108 if (!SWIG_IsOK(res2)) {
48109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
48110 }
48111 arg2 = reinterpret_cast< wxSizer * >(argp2);
48112 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
48113 if (!SWIG_IsOK(res3)) {
48114 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
48115 }
48116 arg3 = reinterpret_cast< wxSizer * >(argp3);
48117 if (obj3) {
48118 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48119 if (!SWIG_IsOK(ecode4)) {
48120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
48121 }
48122 arg4 = static_cast< bool >(val4);
48123 }
48124 {
48125 PyThreadState* __tstate = wxPyBeginAllowThreads();
48126 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
48127 wxPyEndAllowThreads(__tstate);
48128 if (PyErr_Occurred()) SWIG_fail;
48129 }
48130 {
48131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48132 }
48133 return resultobj;
48134 fail:
48135 return NULL;
48136 }
48137
48138
48139 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48140 PyObject *resultobj = 0;
48141 wxSizer *arg1 = (wxSizer *) 0 ;
48142 size_t arg2 ;
48143 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48144 bool result;
48145 void *argp1 = 0 ;
48146 int res1 = 0 ;
48147 size_t val2 ;
48148 int ecode2 = 0 ;
48149 void *argp3 = 0 ;
48150 int res3 = 0 ;
48151 PyObject * obj0 = 0 ;
48152 PyObject * obj1 = 0 ;
48153 PyObject * obj2 = 0 ;
48154 char * kwnames[] = {
48155 (char *) "self",(char *) "index",(char *) "newitem", NULL
48156 };
48157
48158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48160 if (!SWIG_IsOK(res1)) {
48161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48162 }
48163 arg1 = reinterpret_cast< wxSizer * >(argp1);
48164 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48165 if (!SWIG_IsOK(ecode2)) {
48166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
48167 }
48168 arg2 = static_cast< size_t >(val2);
48169 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48170 if (!SWIG_IsOK(res3)) {
48171 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48172 }
48173 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 result = (bool)(arg1)->Replace(arg2,arg3);
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 {
48181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48182 }
48183 return resultobj;
48184 fail:
48185 return NULL;
48186 }
48187
48188
48189 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48190 PyObject *resultobj = 0;
48191 wxSizer *arg1 = (wxSizer *) 0 ;
48192 wxWindow *arg2 = (wxWindow *) 0 ;
48193 void *argp1 = 0 ;
48194 int res1 = 0 ;
48195 void *argp2 = 0 ;
48196 int res2 = 0 ;
48197 PyObject * obj0 = 0 ;
48198 PyObject * obj1 = 0 ;
48199 char * kwnames[] = {
48200 (char *) "self",(char *) "window", NULL
48201 };
48202
48203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
48204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48205 if (!SWIG_IsOK(res1)) {
48206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
48207 }
48208 arg1 = reinterpret_cast< wxSizer * >(argp1);
48209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48210 if (!SWIG_IsOK(res2)) {
48211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
48212 }
48213 arg2 = reinterpret_cast< wxWindow * >(argp2);
48214 {
48215 PyThreadState* __tstate = wxPyBeginAllowThreads();
48216 (arg1)->SetContainingWindow(arg2);
48217 wxPyEndAllowThreads(__tstate);
48218 if (PyErr_Occurred()) SWIG_fail;
48219 }
48220 resultobj = SWIG_Py_Void();
48221 return resultobj;
48222 fail:
48223 return NULL;
48224 }
48225
48226
48227 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48228 PyObject *resultobj = 0;
48229 wxSizer *arg1 = (wxSizer *) 0 ;
48230 wxWindow *result = 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 PyObject *swig_obj[1] ;
48234
48235 if (!args) SWIG_fail;
48236 swig_obj[0] = args;
48237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48238 if (!SWIG_IsOK(res1)) {
48239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
48240 }
48241 arg1 = reinterpret_cast< wxSizer * >(argp1);
48242 {
48243 PyThreadState* __tstate = wxPyBeginAllowThreads();
48244 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
48245 wxPyEndAllowThreads(__tstate);
48246 if (PyErr_Occurred()) SWIG_fail;
48247 }
48248 {
48249 resultobj = wxPyMake_wxObject(result, 0);
48250 }
48251 return resultobj;
48252 fail:
48253 return NULL;
48254 }
48255
48256
48257 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48258 PyObject *resultobj = 0;
48259 wxSizer *arg1 = (wxSizer *) 0 ;
48260 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48261 wxSizerItem *result = 0 ;
48262 void *argp1 = 0 ;
48263 int res1 = 0 ;
48264 int res2 = 0 ;
48265 PyObject * obj0 = 0 ;
48266 PyObject * obj1 = 0 ;
48267 char * kwnames[] = {
48268 (char *) "self",(char *) "item", NULL
48269 };
48270
48271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
48272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48275 }
48276 arg1 = reinterpret_cast< wxSizer * >(argp1);
48277 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48278 if (!SWIG_IsOK(res2)) {
48279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48280 }
48281 {
48282 PyThreadState* __tstate = wxPyBeginAllowThreads();
48283 result = (wxSizerItem *)(arg1)->Add(arg2);
48284 wxPyEndAllowThreads(__tstate);
48285 if (PyErr_Occurred()) SWIG_fail;
48286 }
48287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48288 return resultobj;
48289 fail:
48290 return NULL;
48291 }
48292
48293
48294 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48295 PyObject *resultobj = 0;
48296 wxSizer *arg1 = (wxSizer *) 0 ;
48297 size_t arg2 ;
48298 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
48299 wxSizerItem *result = 0 ;
48300 void *argp1 = 0 ;
48301 int res1 = 0 ;
48302 size_t val2 ;
48303 int ecode2 = 0 ;
48304 int res3 = 0 ;
48305 PyObject * obj0 = 0 ;
48306 PyObject * obj1 = 0 ;
48307 PyObject * obj2 = 0 ;
48308 char * kwnames[] = {
48309 (char *) "self",(char *) "index",(char *) "item", NULL
48310 };
48311
48312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48314 if (!SWIG_IsOK(res1)) {
48315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48316 }
48317 arg1 = reinterpret_cast< wxSizer * >(argp1);
48318 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48319 if (!SWIG_IsOK(ecode2)) {
48320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
48321 }
48322 arg2 = static_cast< size_t >(val2);
48323 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48324 if (!SWIG_IsOK(res3)) {
48325 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
48326 }
48327 {
48328 PyThreadState* __tstate = wxPyBeginAllowThreads();
48329 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
48330 wxPyEndAllowThreads(__tstate);
48331 if (PyErr_Occurred()) SWIG_fail;
48332 }
48333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48334 return resultobj;
48335 fail:
48336 return NULL;
48337 }
48338
48339
48340 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48341 PyObject *resultobj = 0;
48342 wxSizer *arg1 = (wxSizer *) 0 ;
48343 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
48344 wxSizerItem *result = 0 ;
48345 void *argp1 = 0 ;
48346 int res1 = 0 ;
48347 int res2 = 0 ;
48348 PyObject * obj0 = 0 ;
48349 PyObject * obj1 = 0 ;
48350 char * kwnames[] = {
48351 (char *) "self",(char *) "item", NULL
48352 };
48353
48354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
48355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48356 if (!SWIG_IsOK(res1)) {
48357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
48358 }
48359 arg1 = reinterpret_cast< wxSizer * >(argp1);
48360 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48361 if (!SWIG_IsOK(res2)) {
48362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
48363 }
48364 {
48365 PyThreadState* __tstate = wxPyBeginAllowThreads();
48366 result = (wxSizerItem *)(arg1)->Prepend(arg2);
48367 wxPyEndAllowThreads(__tstate);
48368 if (PyErr_Occurred()) SWIG_fail;
48369 }
48370 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
48371 return resultobj;
48372 fail:
48373 return NULL;
48374 }
48375
48376
48377 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48378 PyObject *resultobj = 0;
48379 wxSizer *arg1 = (wxSizer *) 0 ;
48380 int arg2 ;
48381 int arg3 ;
48382 int arg4 ;
48383 int arg5 ;
48384 void *argp1 = 0 ;
48385 int res1 = 0 ;
48386 int val2 ;
48387 int ecode2 = 0 ;
48388 int val3 ;
48389 int ecode3 = 0 ;
48390 int val4 ;
48391 int ecode4 = 0 ;
48392 int val5 ;
48393 int ecode5 = 0 ;
48394 PyObject * obj0 = 0 ;
48395 PyObject * obj1 = 0 ;
48396 PyObject * obj2 = 0 ;
48397 PyObject * obj3 = 0 ;
48398 PyObject * obj4 = 0 ;
48399 char * kwnames[] = {
48400 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
48401 };
48402
48403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48405 if (!SWIG_IsOK(res1)) {
48406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
48407 }
48408 arg1 = reinterpret_cast< wxSizer * >(argp1);
48409 ecode2 = SWIG_AsVal_int(obj1, &val2);
48410 if (!SWIG_IsOK(ecode2)) {
48411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
48412 }
48413 arg2 = static_cast< int >(val2);
48414 ecode3 = SWIG_AsVal_int(obj2, &val3);
48415 if (!SWIG_IsOK(ecode3)) {
48416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
48417 }
48418 arg3 = static_cast< int >(val3);
48419 ecode4 = SWIG_AsVal_int(obj3, &val4);
48420 if (!SWIG_IsOK(ecode4)) {
48421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
48422 }
48423 arg4 = static_cast< int >(val4);
48424 ecode5 = SWIG_AsVal_int(obj4, &val5);
48425 if (!SWIG_IsOK(ecode5)) {
48426 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
48427 }
48428 arg5 = static_cast< int >(val5);
48429 {
48430 PyThreadState* __tstate = wxPyBeginAllowThreads();
48431 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
48432 wxPyEndAllowThreads(__tstate);
48433 if (PyErr_Occurred()) SWIG_fail;
48434 }
48435 resultobj = SWIG_Py_Void();
48436 return resultobj;
48437 fail:
48438 return NULL;
48439 }
48440
48441
48442 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48443 PyObject *resultobj = 0;
48444 wxSizer *arg1 = (wxSizer *) 0 ;
48445 wxSize *arg2 = 0 ;
48446 void *argp1 = 0 ;
48447 int res1 = 0 ;
48448 wxSize temp2 ;
48449 PyObject * obj0 = 0 ;
48450 PyObject * obj1 = 0 ;
48451 char * kwnames[] = {
48452 (char *) "self",(char *) "size", NULL
48453 };
48454
48455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48457 if (!SWIG_IsOK(res1)) {
48458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48459 }
48460 arg1 = reinterpret_cast< wxSizer * >(argp1);
48461 {
48462 arg2 = &temp2;
48463 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48464 }
48465 {
48466 PyThreadState* __tstate = wxPyBeginAllowThreads();
48467 (arg1)->SetMinSize((wxSize const &)*arg2);
48468 wxPyEndAllowThreads(__tstate);
48469 if (PyErr_Occurred()) SWIG_fail;
48470 }
48471 resultobj = SWIG_Py_Void();
48472 return resultobj;
48473 fail:
48474 return NULL;
48475 }
48476
48477
48478 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48479 PyObject *resultobj = 0;
48480 wxSizer *arg1 = (wxSizer *) 0 ;
48481 wxSize result;
48482 void *argp1 = 0 ;
48483 int res1 = 0 ;
48484 PyObject *swig_obj[1] ;
48485
48486 if (!args) SWIG_fail;
48487 swig_obj[0] = args;
48488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48489 if (!SWIG_IsOK(res1)) {
48490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48491 }
48492 arg1 = reinterpret_cast< wxSizer * >(argp1);
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 result = (arg1)->GetSize();
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48500 return resultobj;
48501 fail:
48502 return NULL;
48503 }
48504
48505
48506 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48507 PyObject *resultobj = 0;
48508 wxSizer *arg1 = (wxSizer *) 0 ;
48509 wxPoint result;
48510 void *argp1 = 0 ;
48511 int res1 = 0 ;
48512 PyObject *swig_obj[1] ;
48513
48514 if (!args) SWIG_fail;
48515 swig_obj[0] = args;
48516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48517 if (!SWIG_IsOK(res1)) {
48518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48519 }
48520 arg1 = reinterpret_cast< wxSizer * >(argp1);
48521 {
48522 PyThreadState* __tstate = wxPyBeginAllowThreads();
48523 result = (arg1)->GetPosition();
48524 wxPyEndAllowThreads(__tstate);
48525 if (PyErr_Occurred()) SWIG_fail;
48526 }
48527 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48528 return resultobj;
48529 fail:
48530 return NULL;
48531 }
48532
48533
48534 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48535 PyObject *resultobj = 0;
48536 wxSizer *arg1 = (wxSizer *) 0 ;
48537 wxSize result;
48538 void *argp1 = 0 ;
48539 int res1 = 0 ;
48540 PyObject *swig_obj[1] ;
48541
48542 if (!args) SWIG_fail;
48543 swig_obj[0] = args;
48544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48545 if (!SWIG_IsOK(res1)) {
48546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48547 }
48548 arg1 = reinterpret_cast< wxSizer * >(argp1);
48549 {
48550 PyThreadState* __tstate = wxPyBeginAllowThreads();
48551 result = (arg1)->GetMinSize();
48552 wxPyEndAllowThreads(__tstate);
48553 if (PyErr_Occurred()) SWIG_fail;
48554 }
48555 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48556 return resultobj;
48557 fail:
48558 return NULL;
48559 }
48560
48561
48562 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48563 PyObject *resultobj = 0;
48564 wxSizer *arg1 = (wxSizer *) 0 ;
48565 void *argp1 = 0 ;
48566 int res1 = 0 ;
48567 PyObject *swig_obj[1] ;
48568
48569 if (!args) SWIG_fail;
48570 swig_obj[0] = args;
48571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48572 if (!SWIG_IsOK(res1)) {
48573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48574 }
48575 arg1 = reinterpret_cast< wxSizer * >(argp1);
48576 {
48577 PyThreadState* __tstate = wxPyBeginAllowThreads();
48578 (arg1)->RecalcSizes();
48579 wxPyEndAllowThreads(__tstate);
48580 if (PyErr_Occurred()) SWIG_fail;
48581 }
48582 resultobj = SWIG_Py_Void();
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48590 PyObject *resultobj = 0;
48591 wxSizer *arg1 = (wxSizer *) 0 ;
48592 wxSize result;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 PyObject *swig_obj[1] ;
48596
48597 if (!args) SWIG_fail;
48598 swig_obj[0] = args;
48599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48600 if (!SWIG_IsOK(res1)) {
48601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48602 }
48603 arg1 = reinterpret_cast< wxSizer * >(argp1);
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 result = (arg1)->CalcMin();
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48611 return resultobj;
48612 fail:
48613 return NULL;
48614 }
48615
48616
48617 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48618 PyObject *resultobj = 0;
48619 wxSizer *arg1 = (wxSizer *) 0 ;
48620 void *argp1 = 0 ;
48621 int res1 = 0 ;
48622 PyObject *swig_obj[1] ;
48623
48624 if (!args) SWIG_fail;
48625 swig_obj[0] = args;
48626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48627 if (!SWIG_IsOK(res1)) {
48628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48629 }
48630 arg1 = reinterpret_cast< wxSizer * >(argp1);
48631 {
48632 PyThreadState* __tstate = wxPyBeginAllowThreads();
48633 (arg1)->Layout();
48634 wxPyEndAllowThreads(__tstate);
48635 if (PyErr_Occurred()) SWIG_fail;
48636 }
48637 resultobj = SWIG_Py_Void();
48638 return resultobj;
48639 fail:
48640 return NULL;
48641 }
48642
48643
48644 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48645 PyObject *resultobj = 0;
48646 wxSizer *arg1 = (wxSizer *) 0 ;
48647 wxWindow *arg2 = (wxWindow *) 0 ;
48648 wxSize result;
48649 void *argp1 = 0 ;
48650 int res1 = 0 ;
48651 void *argp2 = 0 ;
48652 int res2 = 0 ;
48653 PyObject * obj0 = 0 ;
48654 PyObject * obj1 = 0 ;
48655 char * kwnames[] = {
48656 (char *) "self",(char *) "window", NULL
48657 };
48658
48659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48661 if (!SWIG_IsOK(res1)) {
48662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48663 }
48664 arg1 = reinterpret_cast< wxSizer * >(argp1);
48665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48666 if (!SWIG_IsOK(res2)) {
48667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48668 }
48669 arg2 = reinterpret_cast< wxWindow * >(argp2);
48670 {
48671 PyThreadState* __tstate = wxPyBeginAllowThreads();
48672 result = (arg1)->Fit(arg2);
48673 wxPyEndAllowThreads(__tstate);
48674 if (PyErr_Occurred()) SWIG_fail;
48675 }
48676 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48677 return resultobj;
48678 fail:
48679 return NULL;
48680 }
48681
48682
48683 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48684 PyObject *resultobj = 0;
48685 wxSizer *arg1 = (wxSizer *) 0 ;
48686 wxWindow *arg2 = (wxWindow *) 0 ;
48687 void *argp1 = 0 ;
48688 int res1 = 0 ;
48689 void *argp2 = 0 ;
48690 int res2 = 0 ;
48691 PyObject * obj0 = 0 ;
48692 PyObject * obj1 = 0 ;
48693 char * kwnames[] = {
48694 (char *) "self",(char *) "window", NULL
48695 };
48696
48697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48699 if (!SWIG_IsOK(res1)) {
48700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48701 }
48702 arg1 = reinterpret_cast< wxSizer * >(argp1);
48703 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48704 if (!SWIG_IsOK(res2)) {
48705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48706 }
48707 arg2 = reinterpret_cast< wxWindow * >(argp2);
48708 {
48709 PyThreadState* __tstate = wxPyBeginAllowThreads();
48710 (arg1)->FitInside(arg2);
48711 wxPyEndAllowThreads(__tstate);
48712 if (PyErr_Occurred()) SWIG_fail;
48713 }
48714 resultobj = SWIG_Py_Void();
48715 return resultobj;
48716 fail:
48717 return NULL;
48718 }
48719
48720
48721 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48722 PyObject *resultobj = 0;
48723 wxSizer *arg1 = (wxSizer *) 0 ;
48724 wxWindow *arg2 = (wxWindow *) 0 ;
48725 void *argp1 = 0 ;
48726 int res1 = 0 ;
48727 void *argp2 = 0 ;
48728 int res2 = 0 ;
48729 PyObject * obj0 = 0 ;
48730 PyObject * obj1 = 0 ;
48731 char * kwnames[] = {
48732 (char *) "self",(char *) "window", NULL
48733 };
48734
48735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48737 if (!SWIG_IsOK(res1)) {
48738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48739 }
48740 arg1 = reinterpret_cast< wxSizer * >(argp1);
48741 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48742 if (!SWIG_IsOK(res2)) {
48743 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48744 }
48745 arg2 = reinterpret_cast< wxWindow * >(argp2);
48746 {
48747 PyThreadState* __tstate = wxPyBeginAllowThreads();
48748 (arg1)->SetSizeHints(arg2);
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 resultobj = SWIG_Py_Void();
48753 return resultobj;
48754 fail:
48755 return NULL;
48756 }
48757
48758
48759 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48760 PyObject *resultobj = 0;
48761 wxSizer *arg1 = (wxSizer *) 0 ;
48762 wxWindow *arg2 = (wxWindow *) 0 ;
48763 void *argp1 = 0 ;
48764 int res1 = 0 ;
48765 void *argp2 = 0 ;
48766 int res2 = 0 ;
48767 PyObject * obj0 = 0 ;
48768 PyObject * obj1 = 0 ;
48769 char * kwnames[] = {
48770 (char *) "self",(char *) "window", NULL
48771 };
48772
48773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48775 if (!SWIG_IsOK(res1)) {
48776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48777 }
48778 arg1 = reinterpret_cast< wxSizer * >(argp1);
48779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48780 if (!SWIG_IsOK(res2)) {
48781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48782 }
48783 arg2 = reinterpret_cast< wxWindow * >(argp2);
48784 {
48785 PyThreadState* __tstate = wxPyBeginAllowThreads();
48786 (arg1)->SetVirtualSizeHints(arg2);
48787 wxPyEndAllowThreads(__tstate);
48788 if (PyErr_Occurred()) SWIG_fail;
48789 }
48790 resultobj = SWIG_Py_Void();
48791 return resultobj;
48792 fail:
48793 return NULL;
48794 }
48795
48796
48797 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48798 PyObject *resultobj = 0;
48799 wxSizer *arg1 = (wxSizer *) 0 ;
48800 bool arg2 = (bool) false ;
48801 void *argp1 = 0 ;
48802 int res1 = 0 ;
48803 bool val2 ;
48804 int ecode2 = 0 ;
48805 PyObject * obj0 = 0 ;
48806 PyObject * obj1 = 0 ;
48807 char * kwnames[] = {
48808 (char *) "self",(char *) "deleteWindows", NULL
48809 };
48810
48811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48813 if (!SWIG_IsOK(res1)) {
48814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48815 }
48816 arg1 = reinterpret_cast< wxSizer * >(argp1);
48817 if (obj1) {
48818 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48819 if (!SWIG_IsOK(ecode2)) {
48820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48821 }
48822 arg2 = static_cast< bool >(val2);
48823 }
48824 {
48825 PyThreadState* __tstate = wxPyBeginAllowThreads();
48826 (arg1)->Clear(arg2);
48827 wxPyEndAllowThreads(__tstate);
48828 if (PyErr_Occurred()) SWIG_fail;
48829 }
48830 resultobj = SWIG_Py_Void();
48831 return resultobj;
48832 fail:
48833 return NULL;
48834 }
48835
48836
48837 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48838 PyObject *resultobj = 0;
48839 wxSizer *arg1 = (wxSizer *) 0 ;
48840 void *argp1 = 0 ;
48841 int res1 = 0 ;
48842 PyObject *swig_obj[1] ;
48843
48844 if (!args) SWIG_fail;
48845 swig_obj[0] = args;
48846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48847 if (!SWIG_IsOK(res1)) {
48848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48849 }
48850 arg1 = reinterpret_cast< wxSizer * >(argp1);
48851 {
48852 PyThreadState* __tstate = wxPyBeginAllowThreads();
48853 (arg1)->DeleteWindows();
48854 wxPyEndAllowThreads(__tstate);
48855 if (PyErr_Occurred()) SWIG_fail;
48856 }
48857 resultobj = SWIG_Py_Void();
48858 return resultobj;
48859 fail:
48860 return NULL;
48861 }
48862
48863
48864 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48865 PyObject *resultobj = 0;
48866 wxSizer *arg1 = (wxSizer *) 0 ;
48867 PyObject *result = 0 ;
48868 void *argp1 = 0 ;
48869 int res1 = 0 ;
48870 PyObject *swig_obj[1] ;
48871
48872 if (!args) SWIG_fail;
48873 swig_obj[0] = args;
48874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48875 if (!SWIG_IsOK(res1)) {
48876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48877 }
48878 arg1 = reinterpret_cast< wxSizer * >(argp1);
48879 {
48880 PyThreadState* __tstate = wxPyBeginAllowThreads();
48881 result = (PyObject *)wxSizer_GetChildren(arg1);
48882 wxPyEndAllowThreads(__tstate);
48883 if (PyErr_Occurred()) SWIG_fail;
48884 }
48885 resultobj = result;
48886 return resultobj;
48887 fail:
48888 return NULL;
48889 }
48890
48891
48892 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48893 PyObject *resultobj = 0;
48894 wxSizer *arg1 = (wxSizer *) 0 ;
48895 PyObject *arg2 = (PyObject *) 0 ;
48896 bool arg3 = (bool) true ;
48897 bool arg4 = (bool) false ;
48898 bool result;
48899 void *argp1 = 0 ;
48900 int res1 = 0 ;
48901 bool val3 ;
48902 int ecode3 = 0 ;
48903 bool val4 ;
48904 int ecode4 = 0 ;
48905 PyObject * obj0 = 0 ;
48906 PyObject * obj1 = 0 ;
48907 PyObject * obj2 = 0 ;
48908 PyObject * obj3 = 0 ;
48909 char * kwnames[] = {
48910 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48911 };
48912
48913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48915 if (!SWIG_IsOK(res1)) {
48916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48917 }
48918 arg1 = reinterpret_cast< wxSizer * >(argp1);
48919 arg2 = obj1;
48920 if (obj2) {
48921 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48922 if (!SWIG_IsOK(ecode3)) {
48923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48924 }
48925 arg3 = static_cast< bool >(val3);
48926 }
48927 if (obj3) {
48928 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48929 if (!SWIG_IsOK(ecode4)) {
48930 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48931 }
48932 arg4 = static_cast< bool >(val4);
48933 }
48934 {
48935 PyThreadState* __tstate = wxPyBeginAllowThreads();
48936 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48937 wxPyEndAllowThreads(__tstate);
48938 if (PyErr_Occurred()) SWIG_fail;
48939 }
48940 {
48941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48942 }
48943 return resultobj;
48944 fail:
48945 return NULL;
48946 }
48947
48948
48949 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48950 PyObject *resultobj = 0;
48951 wxSizer *arg1 = (wxSizer *) 0 ;
48952 PyObject *arg2 = (PyObject *) 0 ;
48953 bool result;
48954 void *argp1 = 0 ;
48955 int res1 = 0 ;
48956 PyObject * obj0 = 0 ;
48957 PyObject * obj1 = 0 ;
48958 char * kwnames[] = {
48959 (char *) "self",(char *) "item", NULL
48960 };
48961
48962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48964 if (!SWIG_IsOK(res1)) {
48965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48966 }
48967 arg1 = reinterpret_cast< wxSizer * >(argp1);
48968 arg2 = obj1;
48969 {
48970 PyThreadState* __tstate = wxPyBeginAllowThreads();
48971 result = (bool)wxSizer_IsShown(arg1,arg2);
48972 wxPyEndAllowThreads(__tstate);
48973 if (PyErr_Occurred()) SWIG_fail;
48974 }
48975 {
48976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48977 }
48978 return resultobj;
48979 fail:
48980 return NULL;
48981 }
48982
48983
48984 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48985 PyObject *resultobj = 0;
48986 wxSizer *arg1 = (wxSizer *) 0 ;
48987 bool arg2 ;
48988 void *argp1 = 0 ;
48989 int res1 = 0 ;
48990 bool val2 ;
48991 int ecode2 = 0 ;
48992 PyObject * obj0 = 0 ;
48993 PyObject * obj1 = 0 ;
48994 char * kwnames[] = {
48995 (char *) "self",(char *) "show", NULL
48996 };
48997
48998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49000 if (!SWIG_IsOK(res1)) {
49001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
49002 }
49003 arg1 = reinterpret_cast< wxSizer * >(argp1);
49004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49005 if (!SWIG_IsOK(ecode2)) {
49006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
49007 }
49008 arg2 = static_cast< bool >(val2);
49009 {
49010 PyThreadState* __tstate = wxPyBeginAllowThreads();
49011 (arg1)->ShowItems(arg2);
49012 wxPyEndAllowThreads(__tstate);
49013 if (PyErr_Occurred()) SWIG_fail;
49014 }
49015 resultobj = SWIG_Py_Void();
49016 return resultobj;
49017 fail:
49018 return NULL;
49019 }
49020
49021
49022 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49023 PyObject *obj;
49024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49025 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
49026 return SWIG_Py_Void();
49027 }
49028
49029 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49030 PyObject *resultobj = 0;
49031 wxPySizer *result = 0 ;
49032
49033 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 result = (wxPySizer *)new wxPySizer();
49037 wxPyEndAllowThreads(__tstate);
49038 if (PyErr_Occurred()) SWIG_fail;
49039 }
49040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
49041 return resultobj;
49042 fail:
49043 return NULL;
49044 }
49045
49046
49047 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49048 PyObject *resultobj = 0;
49049 wxPySizer *arg1 = (wxPySizer *) 0 ;
49050 PyObject *arg2 = (PyObject *) 0 ;
49051 PyObject *arg3 = (PyObject *) 0 ;
49052 void *argp1 = 0 ;
49053 int res1 = 0 ;
49054 PyObject * obj0 = 0 ;
49055 PyObject * obj1 = 0 ;
49056 PyObject * obj2 = 0 ;
49057 char * kwnames[] = {
49058 (char *) "self",(char *) "self",(char *) "_class", NULL
49059 };
49060
49061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
49063 if (!SWIG_IsOK(res1)) {
49064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
49065 }
49066 arg1 = reinterpret_cast< wxPySizer * >(argp1);
49067 arg2 = obj1;
49068 arg3 = obj2;
49069 {
49070 PyThreadState* __tstate = wxPyBeginAllowThreads();
49071 (arg1)->_setCallbackInfo(arg2,arg3);
49072 wxPyEndAllowThreads(__tstate);
49073 if (PyErr_Occurred()) SWIG_fail;
49074 }
49075 resultobj = SWIG_Py_Void();
49076 return resultobj;
49077 fail:
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49083 PyObject *obj;
49084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
49086 return SWIG_Py_Void();
49087 }
49088
49089 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49090 return SWIG_Python_InitShadowInstance(args);
49091 }
49092
49093 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49094 PyObject *resultobj = 0;
49095 int arg1 = (int) wxHORIZONTAL ;
49096 wxBoxSizer *result = 0 ;
49097 int val1 ;
49098 int ecode1 = 0 ;
49099 PyObject * obj0 = 0 ;
49100 char * kwnames[] = {
49101 (char *) "orient", NULL
49102 };
49103
49104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
49105 if (obj0) {
49106 ecode1 = SWIG_AsVal_int(obj0, &val1);
49107 if (!SWIG_IsOK(ecode1)) {
49108 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
49109 }
49110 arg1 = static_cast< int >(val1);
49111 }
49112 {
49113 PyThreadState* __tstate = wxPyBeginAllowThreads();
49114 result = (wxBoxSizer *)new wxBoxSizer(arg1);
49115 wxPyEndAllowThreads(__tstate);
49116 if (PyErr_Occurred()) SWIG_fail;
49117 }
49118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
49119 return resultobj;
49120 fail:
49121 return NULL;
49122 }
49123
49124
49125 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49126 PyObject *resultobj = 0;
49127 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49128 int result;
49129 void *argp1 = 0 ;
49130 int res1 = 0 ;
49131 PyObject *swig_obj[1] ;
49132
49133 if (!args) SWIG_fail;
49134 swig_obj[0] = args;
49135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49136 if (!SWIG_IsOK(res1)) {
49137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49138 }
49139 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49140 {
49141 PyThreadState* __tstate = wxPyBeginAllowThreads();
49142 result = (int)(arg1)->GetOrientation();
49143 wxPyEndAllowThreads(__tstate);
49144 if (PyErr_Occurred()) SWIG_fail;
49145 }
49146 resultobj = SWIG_From_int(static_cast< int >(result));
49147 return resultobj;
49148 fail:
49149 return NULL;
49150 }
49151
49152
49153 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49154 PyObject *resultobj = 0;
49155 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
49156 int arg2 ;
49157 void *argp1 = 0 ;
49158 int res1 = 0 ;
49159 int val2 ;
49160 int ecode2 = 0 ;
49161 PyObject * obj0 = 0 ;
49162 PyObject * obj1 = 0 ;
49163 char * kwnames[] = {
49164 (char *) "self",(char *) "orient", NULL
49165 };
49166
49167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
49168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
49169 if (!SWIG_IsOK(res1)) {
49170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
49171 }
49172 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
49173 ecode2 = SWIG_AsVal_int(obj1, &val2);
49174 if (!SWIG_IsOK(ecode2)) {
49175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
49176 }
49177 arg2 = static_cast< int >(val2);
49178 {
49179 PyThreadState* __tstate = wxPyBeginAllowThreads();
49180 (arg1)->SetOrientation(arg2);
49181 wxPyEndAllowThreads(__tstate);
49182 if (PyErr_Occurred()) SWIG_fail;
49183 }
49184 resultobj = SWIG_Py_Void();
49185 return resultobj;
49186 fail:
49187 return NULL;
49188 }
49189
49190
49191 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49192 PyObject *obj;
49193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49194 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
49195 return SWIG_Py_Void();
49196 }
49197
49198 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49199 return SWIG_Python_InitShadowInstance(args);
49200 }
49201
49202 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49203 PyObject *resultobj = 0;
49204 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
49205 int arg2 = (int) wxHORIZONTAL ;
49206 wxStaticBoxSizer *result = 0 ;
49207 void *argp1 = 0 ;
49208 int res1 = 0 ;
49209 int val2 ;
49210 int ecode2 = 0 ;
49211 PyObject * obj0 = 0 ;
49212 PyObject * obj1 = 0 ;
49213 char * kwnames[] = {
49214 (char *) "box",(char *) "orient", NULL
49215 };
49216
49217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
49219 if (!SWIG_IsOK(res1)) {
49220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
49221 }
49222 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
49223 if (obj1) {
49224 ecode2 = SWIG_AsVal_int(obj1, &val2);
49225 if (!SWIG_IsOK(ecode2)) {
49226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
49227 }
49228 arg2 = static_cast< int >(val2);
49229 }
49230 {
49231 PyThreadState* __tstate = wxPyBeginAllowThreads();
49232 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
49233 wxPyEndAllowThreads(__tstate);
49234 if (PyErr_Occurred()) SWIG_fail;
49235 }
49236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
49237 return resultobj;
49238 fail:
49239 return NULL;
49240 }
49241
49242
49243 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49244 PyObject *resultobj = 0;
49245 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
49246 wxStaticBox *result = 0 ;
49247 void *argp1 = 0 ;
49248 int res1 = 0 ;
49249 PyObject *swig_obj[1] ;
49250
49251 if (!args) SWIG_fail;
49252 swig_obj[0] = args;
49253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
49254 if (!SWIG_IsOK(res1)) {
49255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
49256 }
49257 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
49258 {
49259 PyThreadState* __tstate = wxPyBeginAllowThreads();
49260 result = (wxStaticBox *)(arg1)->GetStaticBox();
49261 wxPyEndAllowThreads(__tstate);
49262 if (PyErr_Occurred()) SWIG_fail;
49263 }
49264 {
49265 resultobj = wxPyMake_wxObject(result, (bool)0);
49266 }
49267 return resultobj;
49268 fail:
49269 return NULL;
49270 }
49271
49272
49273 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49274 PyObject *obj;
49275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49276 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
49277 return SWIG_Py_Void();
49278 }
49279
49280 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49281 return SWIG_Python_InitShadowInstance(args);
49282 }
49283
49284 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49285 PyObject *resultobj = 0;
49286 int arg1 = (int) 1 ;
49287 int arg2 = (int) 0 ;
49288 int arg3 = (int) 0 ;
49289 int arg4 = (int) 0 ;
49290 wxGridSizer *result = 0 ;
49291 int val1 ;
49292 int ecode1 = 0 ;
49293 int val2 ;
49294 int ecode2 = 0 ;
49295 int val3 ;
49296 int ecode3 = 0 ;
49297 int val4 ;
49298 int ecode4 = 0 ;
49299 PyObject * obj0 = 0 ;
49300 PyObject * obj1 = 0 ;
49301 PyObject * obj2 = 0 ;
49302 PyObject * obj3 = 0 ;
49303 char * kwnames[] = {
49304 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49305 };
49306
49307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49308 if (obj0) {
49309 ecode1 = SWIG_AsVal_int(obj0, &val1);
49310 if (!SWIG_IsOK(ecode1)) {
49311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
49312 }
49313 arg1 = static_cast< int >(val1);
49314 }
49315 if (obj1) {
49316 ecode2 = SWIG_AsVal_int(obj1, &val2);
49317 if (!SWIG_IsOK(ecode2)) {
49318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
49319 }
49320 arg2 = static_cast< int >(val2);
49321 }
49322 if (obj2) {
49323 ecode3 = SWIG_AsVal_int(obj2, &val3);
49324 if (!SWIG_IsOK(ecode3)) {
49325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
49326 }
49327 arg3 = static_cast< int >(val3);
49328 }
49329 if (obj3) {
49330 ecode4 = SWIG_AsVal_int(obj3, &val4);
49331 if (!SWIG_IsOK(ecode4)) {
49332 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
49333 }
49334 arg4 = static_cast< int >(val4);
49335 }
49336 {
49337 PyThreadState* __tstate = wxPyBeginAllowThreads();
49338 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
49339 wxPyEndAllowThreads(__tstate);
49340 if (PyErr_Occurred()) SWIG_fail;
49341 }
49342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
49343 return resultobj;
49344 fail:
49345 return NULL;
49346 }
49347
49348
49349 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49350 PyObject *resultobj = 0;
49351 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49352 int arg2 ;
49353 void *argp1 = 0 ;
49354 int res1 = 0 ;
49355 int val2 ;
49356 int ecode2 = 0 ;
49357 PyObject * obj0 = 0 ;
49358 PyObject * obj1 = 0 ;
49359 char * kwnames[] = {
49360 (char *) "self",(char *) "cols", NULL
49361 };
49362
49363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
49364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49365 if (!SWIG_IsOK(res1)) {
49366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49367 }
49368 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49369 ecode2 = SWIG_AsVal_int(obj1, &val2);
49370 if (!SWIG_IsOK(ecode2)) {
49371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
49372 }
49373 arg2 = static_cast< int >(val2);
49374 {
49375 PyThreadState* __tstate = wxPyBeginAllowThreads();
49376 (arg1)->SetCols(arg2);
49377 wxPyEndAllowThreads(__tstate);
49378 if (PyErr_Occurred()) SWIG_fail;
49379 }
49380 resultobj = SWIG_Py_Void();
49381 return resultobj;
49382 fail:
49383 return NULL;
49384 }
49385
49386
49387 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49388 PyObject *resultobj = 0;
49389 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49390 int arg2 ;
49391 void *argp1 = 0 ;
49392 int res1 = 0 ;
49393 int val2 ;
49394 int ecode2 = 0 ;
49395 PyObject * obj0 = 0 ;
49396 PyObject * obj1 = 0 ;
49397 char * kwnames[] = {
49398 (char *) "self",(char *) "rows", NULL
49399 };
49400
49401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
49402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49405 }
49406 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49407 ecode2 = SWIG_AsVal_int(obj1, &val2);
49408 if (!SWIG_IsOK(ecode2)) {
49409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
49410 }
49411 arg2 = static_cast< int >(val2);
49412 {
49413 PyThreadState* __tstate = wxPyBeginAllowThreads();
49414 (arg1)->SetRows(arg2);
49415 wxPyEndAllowThreads(__tstate);
49416 if (PyErr_Occurred()) SWIG_fail;
49417 }
49418 resultobj = SWIG_Py_Void();
49419 return resultobj;
49420 fail:
49421 return NULL;
49422 }
49423
49424
49425 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49426 PyObject *resultobj = 0;
49427 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49428 int arg2 ;
49429 void *argp1 = 0 ;
49430 int res1 = 0 ;
49431 int val2 ;
49432 int ecode2 = 0 ;
49433 PyObject * obj0 = 0 ;
49434 PyObject * obj1 = 0 ;
49435 char * kwnames[] = {
49436 (char *) "self",(char *) "gap", NULL
49437 };
49438
49439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
49440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49441 if (!SWIG_IsOK(res1)) {
49442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49443 }
49444 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49445 ecode2 = SWIG_AsVal_int(obj1, &val2);
49446 if (!SWIG_IsOK(ecode2)) {
49447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
49448 }
49449 arg2 = static_cast< int >(val2);
49450 {
49451 PyThreadState* __tstate = wxPyBeginAllowThreads();
49452 (arg1)->SetVGap(arg2);
49453 wxPyEndAllowThreads(__tstate);
49454 if (PyErr_Occurred()) SWIG_fail;
49455 }
49456 resultobj = SWIG_Py_Void();
49457 return resultobj;
49458 fail:
49459 return NULL;
49460 }
49461
49462
49463 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49464 PyObject *resultobj = 0;
49465 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49466 int arg2 ;
49467 void *argp1 = 0 ;
49468 int res1 = 0 ;
49469 int val2 ;
49470 int ecode2 = 0 ;
49471 PyObject * obj0 = 0 ;
49472 PyObject * obj1 = 0 ;
49473 char * kwnames[] = {
49474 (char *) "self",(char *) "gap", NULL
49475 };
49476
49477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49479 if (!SWIG_IsOK(res1)) {
49480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49481 }
49482 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49483 ecode2 = SWIG_AsVal_int(obj1, &val2);
49484 if (!SWIG_IsOK(ecode2)) {
49485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49486 }
49487 arg2 = static_cast< int >(val2);
49488 {
49489 PyThreadState* __tstate = wxPyBeginAllowThreads();
49490 (arg1)->SetHGap(arg2);
49491 wxPyEndAllowThreads(__tstate);
49492 if (PyErr_Occurred()) SWIG_fail;
49493 }
49494 resultobj = SWIG_Py_Void();
49495 return resultobj;
49496 fail:
49497 return NULL;
49498 }
49499
49500
49501 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49502 PyObject *resultobj = 0;
49503 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49504 int result;
49505 void *argp1 = 0 ;
49506 int res1 = 0 ;
49507 PyObject *swig_obj[1] ;
49508
49509 if (!args) SWIG_fail;
49510 swig_obj[0] = args;
49511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49512 if (!SWIG_IsOK(res1)) {
49513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49514 }
49515 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49516 {
49517 PyThreadState* __tstate = wxPyBeginAllowThreads();
49518 result = (int)(arg1)->GetCols();
49519 wxPyEndAllowThreads(__tstate);
49520 if (PyErr_Occurred()) SWIG_fail;
49521 }
49522 resultobj = SWIG_From_int(static_cast< int >(result));
49523 return resultobj;
49524 fail:
49525 return NULL;
49526 }
49527
49528
49529 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49530 PyObject *resultobj = 0;
49531 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49532 int result;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 PyObject *swig_obj[1] ;
49536
49537 if (!args) SWIG_fail;
49538 swig_obj[0] = args;
49539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49540 if (!SWIG_IsOK(res1)) {
49541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49542 }
49543 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49544 {
49545 PyThreadState* __tstate = wxPyBeginAllowThreads();
49546 result = (int)(arg1)->GetRows();
49547 wxPyEndAllowThreads(__tstate);
49548 if (PyErr_Occurred()) SWIG_fail;
49549 }
49550 resultobj = SWIG_From_int(static_cast< int >(result));
49551 return resultobj;
49552 fail:
49553 return NULL;
49554 }
49555
49556
49557 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49558 PyObject *resultobj = 0;
49559 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49560 int result;
49561 void *argp1 = 0 ;
49562 int res1 = 0 ;
49563 PyObject *swig_obj[1] ;
49564
49565 if (!args) SWIG_fail;
49566 swig_obj[0] = args;
49567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49568 if (!SWIG_IsOK(res1)) {
49569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49570 }
49571 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49572 {
49573 PyThreadState* __tstate = wxPyBeginAllowThreads();
49574 result = (int)(arg1)->GetVGap();
49575 wxPyEndAllowThreads(__tstate);
49576 if (PyErr_Occurred()) SWIG_fail;
49577 }
49578 resultobj = SWIG_From_int(static_cast< int >(result));
49579 return resultobj;
49580 fail:
49581 return NULL;
49582 }
49583
49584
49585 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49586 PyObject *resultobj = 0;
49587 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49588 int result;
49589 void *argp1 = 0 ;
49590 int res1 = 0 ;
49591 PyObject *swig_obj[1] ;
49592
49593 if (!args) SWIG_fail;
49594 swig_obj[0] = args;
49595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49596 if (!SWIG_IsOK(res1)) {
49597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49598 }
49599 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49600 {
49601 PyThreadState* __tstate = wxPyBeginAllowThreads();
49602 result = (int)(arg1)->GetHGap();
49603 wxPyEndAllowThreads(__tstate);
49604 if (PyErr_Occurred()) SWIG_fail;
49605 }
49606 resultobj = SWIG_From_int(static_cast< int >(result));
49607 return resultobj;
49608 fail:
49609 return NULL;
49610 }
49611
49612
49613 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49614 PyObject *obj;
49615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49616 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49617 return SWIG_Py_Void();
49618 }
49619
49620 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49621 return SWIG_Python_InitShadowInstance(args);
49622 }
49623
49624 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49625 PyObject *resultobj = 0;
49626 int arg1 = (int) 1 ;
49627 int arg2 = (int) 0 ;
49628 int arg3 = (int) 0 ;
49629 int arg4 = (int) 0 ;
49630 wxFlexGridSizer *result = 0 ;
49631 int val1 ;
49632 int ecode1 = 0 ;
49633 int val2 ;
49634 int ecode2 = 0 ;
49635 int val3 ;
49636 int ecode3 = 0 ;
49637 int val4 ;
49638 int ecode4 = 0 ;
49639 PyObject * obj0 = 0 ;
49640 PyObject * obj1 = 0 ;
49641 PyObject * obj2 = 0 ;
49642 PyObject * obj3 = 0 ;
49643 char * kwnames[] = {
49644 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49645 };
49646
49647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49648 if (obj0) {
49649 ecode1 = SWIG_AsVal_int(obj0, &val1);
49650 if (!SWIG_IsOK(ecode1)) {
49651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49652 }
49653 arg1 = static_cast< int >(val1);
49654 }
49655 if (obj1) {
49656 ecode2 = SWIG_AsVal_int(obj1, &val2);
49657 if (!SWIG_IsOK(ecode2)) {
49658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49659 }
49660 arg2 = static_cast< int >(val2);
49661 }
49662 if (obj2) {
49663 ecode3 = SWIG_AsVal_int(obj2, &val3);
49664 if (!SWIG_IsOK(ecode3)) {
49665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49666 }
49667 arg3 = static_cast< int >(val3);
49668 }
49669 if (obj3) {
49670 ecode4 = SWIG_AsVal_int(obj3, &val4);
49671 if (!SWIG_IsOK(ecode4)) {
49672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49673 }
49674 arg4 = static_cast< int >(val4);
49675 }
49676 {
49677 PyThreadState* __tstate = wxPyBeginAllowThreads();
49678 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49679 wxPyEndAllowThreads(__tstate);
49680 if (PyErr_Occurred()) SWIG_fail;
49681 }
49682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49683 return resultobj;
49684 fail:
49685 return NULL;
49686 }
49687
49688
49689 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49690 PyObject *resultobj = 0;
49691 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49692 size_t arg2 ;
49693 int arg3 = (int) 0 ;
49694 void *argp1 = 0 ;
49695 int res1 = 0 ;
49696 size_t val2 ;
49697 int ecode2 = 0 ;
49698 int val3 ;
49699 int ecode3 = 0 ;
49700 PyObject * obj0 = 0 ;
49701 PyObject * obj1 = 0 ;
49702 PyObject * obj2 = 0 ;
49703 char * kwnames[] = {
49704 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49705 };
49706
49707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49709 if (!SWIG_IsOK(res1)) {
49710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49711 }
49712 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49713 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49714 if (!SWIG_IsOK(ecode2)) {
49715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49716 }
49717 arg2 = static_cast< size_t >(val2);
49718 if (obj2) {
49719 ecode3 = SWIG_AsVal_int(obj2, &val3);
49720 if (!SWIG_IsOK(ecode3)) {
49721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49722 }
49723 arg3 = static_cast< int >(val3);
49724 }
49725 {
49726 PyThreadState* __tstate = wxPyBeginAllowThreads();
49727 (arg1)->AddGrowableRow(arg2,arg3);
49728 wxPyEndAllowThreads(__tstate);
49729 if (PyErr_Occurred()) SWIG_fail;
49730 }
49731 resultobj = SWIG_Py_Void();
49732 return resultobj;
49733 fail:
49734 return NULL;
49735 }
49736
49737
49738 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49739 PyObject *resultobj = 0;
49740 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49741 size_t arg2 ;
49742 void *argp1 = 0 ;
49743 int res1 = 0 ;
49744 size_t val2 ;
49745 int ecode2 = 0 ;
49746 PyObject * obj0 = 0 ;
49747 PyObject * obj1 = 0 ;
49748 char * kwnames[] = {
49749 (char *) "self",(char *) "idx", NULL
49750 };
49751
49752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49754 if (!SWIG_IsOK(res1)) {
49755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49756 }
49757 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49758 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49759 if (!SWIG_IsOK(ecode2)) {
49760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49761 }
49762 arg2 = static_cast< size_t >(val2);
49763 {
49764 PyThreadState* __tstate = wxPyBeginAllowThreads();
49765 (arg1)->RemoveGrowableRow(arg2);
49766 wxPyEndAllowThreads(__tstate);
49767 if (PyErr_Occurred()) SWIG_fail;
49768 }
49769 resultobj = SWIG_Py_Void();
49770 return resultobj;
49771 fail:
49772 return NULL;
49773 }
49774
49775
49776 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49777 PyObject *resultobj = 0;
49778 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49779 size_t arg2 ;
49780 int arg3 = (int) 0 ;
49781 void *argp1 = 0 ;
49782 int res1 = 0 ;
49783 size_t val2 ;
49784 int ecode2 = 0 ;
49785 int val3 ;
49786 int ecode3 = 0 ;
49787 PyObject * obj0 = 0 ;
49788 PyObject * obj1 = 0 ;
49789 PyObject * obj2 = 0 ;
49790 char * kwnames[] = {
49791 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49792 };
49793
49794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49796 if (!SWIG_IsOK(res1)) {
49797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49798 }
49799 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49800 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49801 if (!SWIG_IsOK(ecode2)) {
49802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49803 }
49804 arg2 = static_cast< size_t >(val2);
49805 if (obj2) {
49806 ecode3 = SWIG_AsVal_int(obj2, &val3);
49807 if (!SWIG_IsOK(ecode3)) {
49808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49809 }
49810 arg3 = static_cast< int >(val3);
49811 }
49812 {
49813 PyThreadState* __tstate = wxPyBeginAllowThreads();
49814 (arg1)->AddGrowableCol(arg2,arg3);
49815 wxPyEndAllowThreads(__tstate);
49816 if (PyErr_Occurred()) SWIG_fail;
49817 }
49818 resultobj = SWIG_Py_Void();
49819 return resultobj;
49820 fail:
49821 return NULL;
49822 }
49823
49824
49825 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49826 PyObject *resultobj = 0;
49827 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49828 size_t arg2 ;
49829 void *argp1 = 0 ;
49830 int res1 = 0 ;
49831 size_t val2 ;
49832 int ecode2 = 0 ;
49833 PyObject * obj0 = 0 ;
49834 PyObject * obj1 = 0 ;
49835 char * kwnames[] = {
49836 (char *) "self",(char *) "idx", NULL
49837 };
49838
49839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49841 if (!SWIG_IsOK(res1)) {
49842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49843 }
49844 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49846 if (!SWIG_IsOK(ecode2)) {
49847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49848 }
49849 arg2 = static_cast< size_t >(val2);
49850 {
49851 PyThreadState* __tstate = wxPyBeginAllowThreads();
49852 (arg1)->RemoveGrowableCol(arg2);
49853 wxPyEndAllowThreads(__tstate);
49854 if (PyErr_Occurred()) SWIG_fail;
49855 }
49856 resultobj = SWIG_Py_Void();
49857 return resultobj;
49858 fail:
49859 return NULL;
49860 }
49861
49862
49863 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49864 PyObject *resultobj = 0;
49865 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49866 int arg2 ;
49867 void *argp1 = 0 ;
49868 int res1 = 0 ;
49869 int val2 ;
49870 int ecode2 = 0 ;
49871 PyObject * obj0 = 0 ;
49872 PyObject * obj1 = 0 ;
49873 char * kwnames[] = {
49874 (char *) "self",(char *) "direction", NULL
49875 };
49876
49877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49879 if (!SWIG_IsOK(res1)) {
49880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49881 }
49882 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49883 ecode2 = SWIG_AsVal_int(obj1, &val2);
49884 if (!SWIG_IsOK(ecode2)) {
49885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49886 }
49887 arg2 = static_cast< int >(val2);
49888 {
49889 PyThreadState* __tstate = wxPyBeginAllowThreads();
49890 (arg1)->SetFlexibleDirection(arg2);
49891 wxPyEndAllowThreads(__tstate);
49892 if (PyErr_Occurred()) SWIG_fail;
49893 }
49894 resultobj = SWIG_Py_Void();
49895 return resultobj;
49896 fail:
49897 return NULL;
49898 }
49899
49900
49901 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49902 PyObject *resultobj = 0;
49903 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49904 int result;
49905 void *argp1 = 0 ;
49906 int res1 = 0 ;
49907 PyObject *swig_obj[1] ;
49908
49909 if (!args) SWIG_fail;
49910 swig_obj[0] = args;
49911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49912 if (!SWIG_IsOK(res1)) {
49913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49914 }
49915 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49916 {
49917 PyThreadState* __tstate = wxPyBeginAllowThreads();
49918 result = (int)(arg1)->GetFlexibleDirection();
49919 wxPyEndAllowThreads(__tstate);
49920 if (PyErr_Occurred()) SWIG_fail;
49921 }
49922 resultobj = SWIG_From_int(static_cast< int >(result));
49923 return resultobj;
49924 fail:
49925 return NULL;
49926 }
49927
49928
49929 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49930 PyObject *resultobj = 0;
49931 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49932 wxFlexSizerGrowMode arg2 ;
49933 void *argp1 = 0 ;
49934 int res1 = 0 ;
49935 int val2 ;
49936 int ecode2 = 0 ;
49937 PyObject * obj0 = 0 ;
49938 PyObject * obj1 = 0 ;
49939 char * kwnames[] = {
49940 (char *) "self",(char *) "mode", NULL
49941 };
49942
49943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49945 if (!SWIG_IsOK(res1)) {
49946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49947 }
49948 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49949 ecode2 = SWIG_AsVal_int(obj1, &val2);
49950 if (!SWIG_IsOK(ecode2)) {
49951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49952 }
49953 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49954 {
49955 PyThreadState* __tstate = wxPyBeginAllowThreads();
49956 (arg1)->SetNonFlexibleGrowMode(arg2);
49957 wxPyEndAllowThreads(__tstate);
49958 if (PyErr_Occurred()) SWIG_fail;
49959 }
49960 resultobj = SWIG_Py_Void();
49961 return resultobj;
49962 fail:
49963 return NULL;
49964 }
49965
49966
49967 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49968 PyObject *resultobj = 0;
49969 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49970 wxFlexSizerGrowMode result;
49971 void *argp1 = 0 ;
49972 int res1 = 0 ;
49973 PyObject *swig_obj[1] ;
49974
49975 if (!args) SWIG_fail;
49976 swig_obj[0] = args;
49977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49978 if (!SWIG_IsOK(res1)) {
49979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49980 }
49981 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49982 {
49983 PyThreadState* __tstate = wxPyBeginAllowThreads();
49984 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49985 wxPyEndAllowThreads(__tstate);
49986 if (PyErr_Occurred()) SWIG_fail;
49987 }
49988 resultobj = SWIG_From_int(static_cast< int >(result));
49989 return resultobj;
49990 fail:
49991 return NULL;
49992 }
49993
49994
49995 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49996 PyObject *resultobj = 0;
49997 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49998 wxArrayInt *result = 0 ;
49999 void *argp1 = 0 ;
50000 int res1 = 0 ;
50001 PyObject *swig_obj[1] ;
50002
50003 if (!args) SWIG_fail;
50004 swig_obj[0] = args;
50005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50006 if (!SWIG_IsOK(res1)) {
50007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50008 }
50009 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50010 {
50011 PyThreadState* __tstate = wxPyBeginAllowThreads();
50012 {
50013 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
50014 result = (wxArrayInt *) &_result_ref;
50015 }
50016 wxPyEndAllowThreads(__tstate);
50017 if (PyErr_Occurred()) SWIG_fail;
50018 }
50019 {
50020 resultobj = wxArrayInt2PyList_helper(*result);
50021 }
50022 return resultobj;
50023 fail:
50024 return NULL;
50025 }
50026
50027
50028 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50029 PyObject *resultobj = 0;
50030 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
50031 wxArrayInt *result = 0 ;
50032 void *argp1 = 0 ;
50033 int res1 = 0 ;
50034 PyObject *swig_obj[1] ;
50035
50036 if (!args) SWIG_fail;
50037 swig_obj[0] = args;
50038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
50039 if (!SWIG_IsOK(res1)) {
50040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
50041 }
50042 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
50043 {
50044 PyThreadState* __tstate = wxPyBeginAllowThreads();
50045 {
50046 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
50047 result = (wxArrayInt *) &_result_ref;
50048 }
50049 wxPyEndAllowThreads(__tstate);
50050 if (PyErr_Occurred()) SWIG_fail;
50051 }
50052 {
50053 resultobj = wxArrayInt2PyList_helper(*result);
50054 }
50055 return resultobj;
50056 fail:
50057 return NULL;
50058 }
50059
50060
50061 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50062 PyObject *obj;
50063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50064 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
50065 return SWIG_Py_Void();
50066 }
50067
50068 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50069 return SWIG_Python_InitShadowInstance(args);
50070 }
50071
50072 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50073 PyObject *resultobj = 0;
50074 wxStdDialogButtonSizer *result = 0 ;
50075
50076 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
50077 {
50078 PyThreadState* __tstate = wxPyBeginAllowThreads();
50079 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
50080 wxPyEndAllowThreads(__tstate);
50081 if (PyErr_Occurred()) SWIG_fail;
50082 }
50083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
50084 return resultobj;
50085 fail:
50086 return NULL;
50087 }
50088
50089
50090 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50091 PyObject *resultobj = 0;
50092 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50093 wxButton *arg2 = (wxButton *) 0 ;
50094 void *argp1 = 0 ;
50095 int res1 = 0 ;
50096 void *argp2 = 0 ;
50097 int res2 = 0 ;
50098 PyObject * obj0 = 0 ;
50099 PyObject * obj1 = 0 ;
50100 char * kwnames[] = {
50101 (char *) "self",(char *) "button", NULL
50102 };
50103
50104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
50105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50106 if (!SWIG_IsOK(res1)) {
50107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50108 }
50109 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50111 if (!SWIG_IsOK(res2)) {
50112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
50113 }
50114 arg2 = reinterpret_cast< wxButton * >(argp2);
50115 {
50116 PyThreadState* __tstate = wxPyBeginAllowThreads();
50117 (arg1)->AddButton(arg2);
50118 wxPyEndAllowThreads(__tstate);
50119 if (PyErr_Occurred()) SWIG_fail;
50120 }
50121 resultobj = SWIG_Py_Void();
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50129 PyObject *resultobj = 0;
50130 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50131 void *argp1 = 0 ;
50132 int res1 = 0 ;
50133 PyObject *swig_obj[1] ;
50134
50135 if (!args) SWIG_fail;
50136 swig_obj[0] = args;
50137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50138 if (!SWIG_IsOK(res1)) {
50139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50140 }
50141 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50142 {
50143 PyThreadState* __tstate = wxPyBeginAllowThreads();
50144 (arg1)->Realize();
50145 wxPyEndAllowThreads(__tstate);
50146 if (PyErr_Occurred()) SWIG_fail;
50147 }
50148 resultobj = SWIG_Py_Void();
50149 return resultobj;
50150 fail:
50151 return NULL;
50152 }
50153
50154
50155 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50156 PyObject *resultobj = 0;
50157 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50158 wxButton *arg2 = (wxButton *) 0 ;
50159 void *argp1 = 0 ;
50160 int res1 = 0 ;
50161 void *argp2 = 0 ;
50162 int res2 = 0 ;
50163 PyObject * obj0 = 0 ;
50164 PyObject * obj1 = 0 ;
50165 char * kwnames[] = {
50166 (char *) "self",(char *) "button", NULL
50167 };
50168
50169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50171 if (!SWIG_IsOK(res1)) {
50172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50173 }
50174 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50176 if (!SWIG_IsOK(res2)) {
50177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50178 }
50179 arg2 = reinterpret_cast< wxButton * >(argp2);
50180 {
50181 PyThreadState* __tstate = wxPyBeginAllowThreads();
50182 (arg1)->SetAffirmativeButton(arg2);
50183 wxPyEndAllowThreads(__tstate);
50184 if (PyErr_Occurred()) SWIG_fail;
50185 }
50186 resultobj = SWIG_Py_Void();
50187 return resultobj;
50188 fail:
50189 return NULL;
50190 }
50191
50192
50193 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50194 PyObject *resultobj = 0;
50195 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50196 wxButton *arg2 = (wxButton *) 0 ;
50197 void *argp1 = 0 ;
50198 int res1 = 0 ;
50199 void *argp2 = 0 ;
50200 int res2 = 0 ;
50201 PyObject * obj0 = 0 ;
50202 PyObject * obj1 = 0 ;
50203 char * kwnames[] = {
50204 (char *) "self",(char *) "button", NULL
50205 };
50206
50207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
50208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50209 if (!SWIG_IsOK(res1)) {
50210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50211 }
50212 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50214 if (!SWIG_IsOK(res2)) {
50215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
50216 }
50217 arg2 = reinterpret_cast< wxButton * >(argp2);
50218 {
50219 PyThreadState* __tstate = wxPyBeginAllowThreads();
50220 (arg1)->SetNegativeButton(arg2);
50221 wxPyEndAllowThreads(__tstate);
50222 if (PyErr_Occurred()) SWIG_fail;
50223 }
50224 resultobj = SWIG_Py_Void();
50225 return resultobj;
50226 fail:
50227 return NULL;
50228 }
50229
50230
50231 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50232 PyObject *resultobj = 0;
50233 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50234 wxButton *arg2 = (wxButton *) 0 ;
50235 void *argp1 = 0 ;
50236 int res1 = 0 ;
50237 void *argp2 = 0 ;
50238 int res2 = 0 ;
50239 PyObject * obj0 = 0 ;
50240 PyObject * obj1 = 0 ;
50241 char * kwnames[] = {
50242 (char *) "self",(char *) "button", NULL
50243 };
50244
50245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
50246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50247 if (!SWIG_IsOK(res1)) {
50248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
50249 }
50250 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
50252 if (!SWIG_IsOK(res2)) {
50253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
50254 }
50255 arg2 = reinterpret_cast< wxButton * >(argp2);
50256 {
50257 PyThreadState* __tstate = wxPyBeginAllowThreads();
50258 (arg1)->SetCancelButton(arg2);
50259 wxPyEndAllowThreads(__tstate);
50260 if (PyErr_Occurred()) SWIG_fail;
50261 }
50262 resultobj = SWIG_Py_Void();
50263 return resultobj;
50264 fail:
50265 return NULL;
50266 }
50267
50268
50269 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50270 PyObject *resultobj = 0;
50271 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50272 wxButton *result = 0 ;
50273 void *argp1 = 0 ;
50274 int res1 = 0 ;
50275 PyObject *swig_obj[1] ;
50276
50277 if (!args) SWIG_fail;
50278 swig_obj[0] = args;
50279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50280 if (!SWIG_IsOK(res1)) {
50281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50282 }
50283 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50284 {
50285 PyThreadState* __tstate = wxPyBeginAllowThreads();
50286 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
50287 wxPyEndAllowThreads(__tstate);
50288 if (PyErr_Occurred()) SWIG_fail;
50289 }
50290 {
50291 resultobj = wxPyMake_wxObject(result, (bool)0);
50292 }
50293 return resultobj;
50294 fail:
50295 return NULL;
50296 }
50297
50298
50299 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50300 PyObject *resultobj = 0;
50301 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50302 wxButton *result = 0 ;
50303 void *argp1 = 0 ;
50304 int res1 = 0 ;
50305 PyObject *swig_obj[1] ;
50306
50307 if (!args) SWIG_fail;
50308 swig_obj[0] = args;
50309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50310 if (!SWIG_IsOK(res1)) {
50311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50312 }
50313 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50314 {
50315 PyThreadState* __tstate = wxPyBeginAllowThreads();
50316 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
50317 wxPyEndAllowThreads(__tstate);
50318 if (PyErr_Occurred()) SWIG_fail;
50319 }
50320 {
50321 resultobj = wxPyMake_wxObject(result, (bool)0);
50322 }
50323 return resultobj;
50324 fail:
50325 return NULL;
50326 }
50327
50328
50329 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50330 PyObject *resultobj = 0;
50331 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50332 wxButton *result = 0 ;
50333 void *argp1 = 0 ;
50334 int res1 = 0 ;
50335 PyObject *swig_obj[1] ;
50336
50337 if (!args) SWIG_fail;
50338 swig_obj[0] = args;
50339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50340 if (!SWIG_IsOK(res1)) {
50341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50342 }
50343 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50344 {
50345 PyThreadState* __tstate = wxPyBeginAllowThreads();
50346 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
50347 wxPyEndAllowThreads(__tstate);
50348 if (PyErr_Occurred()) SWIG_fail;
50349 }
50350 {
50351 resultobj = wxPyMake_wxObject(result, (bool)0);
50352 }
50353 return resultobj;
50354 fail:
50355 return NULL;
50356 }
50357
50358
50359 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50360 PyObject *resultobj = 0;
50361 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50362 wxButton *result = 0 ;
50363 void *argp1 = 0 ;
50364 int res1 = 0 ;
50365 PyObject *swig_obj[1] ;
50366
50367 if (!args) SWIG_fail;
50368 swig_obj[0] = args;
50369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50370 if (!SWIG_IsOK(res1)) {
50371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50372 }
50373 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50374 {
50375 PyThreadState* __tstate = wxPyBeginAllowThreads();
50376 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
50377 wxPyEndAllowThreads(__tstate);
50378 if (PyErr_Occurred()) SWIG_fail;
50379 }
50380 {
50381 resultobj = wxPyMake_wxObject(result, (bool)0);
50382 }
50383 return resultobj;
50384 fail:
50385 return NULL;
50386 }
50387
50388
50389 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50390 PyObject *resultobj = 0;
50391 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
50392 wxButton *result = 0 ;
50393 void *argp1 = 0 ;
50394 int res1 = 0 ;
50395 PyObject *swig_obj[1] ;
50396
50397 if (!args) SWIG_fail;
50398 swig_obj[0] = args;
50399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
50402 }
50403 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
50404 {
50405 PyThreadState* __tstate = wxPyBeginAllowThreads();
50406 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
50407 wxPyEndAllowThreads(__tstate);
50408 if (PyErr_Occurred()) SWIG_fail;
50409 }
50410 {
50411 resultobj = wxPyMake_wxObject(result, (bool)0);
50412 }
50413 return resultobj;
50414 fail:
50415 return NULL;
50416 }
50417
50418
50419 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50420 PyObject *obj;
50421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50422 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
50423 return SWIG_Py_Void();
50424 }
50425
50426 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50427 return SWIG_Python_InitShadowInstance(args);
50428 }
50429
50430 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50431 PyObject *resultobj = 0;
50432 int arg1 = (int) 0 ;
50433 int arg2 = (int) 0 ;
50434 wxGBPosition *result = 0 ;
50435 int val1 ;
50436 int ecode1 = 0 ;
50437 int val2 ;
50438 int ecode2 = 0 ;
50439 PyObject * obj0 = 0 ;
50440 PyObject * obj1 = 0 ;
50441 char * kwnames[] = {
50442 (char *) "row",(char *) "col", NULL
50443 };
50444
50445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50446 if (obj0) {
50447 ecode1 = SWIG_AsVal_int(obj0, &val1);
50448 if (!SWIG_IsOK(ecode1)) {
50449 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50450 }
50451 arg1 = static_cast< int >(val1);
50452 }
50453 if (obj1) {
50454 ecode2 = SWIG_AsVal_int(obj1, &val2);
50455 if (!SWIG_IsOK(ecode2)) {
50456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50457 }
50458 arg2 = static_cast< int >(val2);
50459 }
50460 {
50461 PyThreadState* __tstate = wxPyBeginAllowThreads();
50462 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50463 wxPyEndAllowThreads(__tstate);
50464 if (PyErr_Occurred()) SWIG_fail;
50465 }
50466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50467 return resultobj;
50468 fail:
50469 return NULL;
50470 }
50471
50472
50473 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50474 PyObject *resultobj = 0;
50475 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 PyObject *swig_obj[1] ;
50479
50480 if (!args) SWIG_fail;
50481 swig_obj[0] = args;
50482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50483 if (!SWIG_IsOK(res1)) {
50484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50485 }
50486 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50487 {
50488 PyThreadState* __tstate = wxPyBeginAllowThreads();
50489 delete arg1;
50490
50491 wxPyEndAllowThreads(__tstate);
50492 if (PyErr_Occurred()) SWIG_fail;
50493 }
50494 resultobj = SWIG_Py_Void();
50495 return resultobj;
50496 fail:
50497 return NULL;
50498 }
50499
50500
50501 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50502 PyObject *resultobj = 0;
50503 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50504 int result;
50505 void *argp1 = 0 ;
50506 int res1 = 0 ;
50507 PyObject *swig_obj[1] ;
50508
50509 if (!args) SWIG_fail;
50510 swig_obj[0] = args;
50511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50512 if (!SWIG_IsOK(res1)) {
50513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50514 }
50515 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50516 {
50517 PyThreadState* __tstate = wxPyBeginAllowThreads();
50518 result = (int)((wxGBPosition const *)arg1)->GetRow();
50519 wxPyEndAllowThreads(__tstate);
50520 if (PyErr_Occurred()) SWIG_fail;
50521 }
50522 resultobj = SWIG_From_int(static_cast< int >(result));
50523 return resultobj;
50524 fail:
50525 return NULL;
50526 }
50527
50528
50529 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50530 PyObject *resultobj = 0;
50531 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50532 int result;
50533 void *argp1 = 0 ;
50534 int res1 = 0 ;
50535 PyObject *swig_obj[1] ;
50536
50537 if (!args) SWIG_fail;
50538 swig_obj[0] = args;
50539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50540 if (!SWIG_IsOK(res1)) {
50541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50542 }
50543 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50544 {
50545 PyThreadState* __tstate = wxPyBeginAllowThreads();
50546 result = (int)((wxGBPosition const *)arg1)->GetCol();
50547 wxPyEndAllowThreads(__tstate);
50548 if (PyErr_Occurred()) SWIG_fail;
50549 }
50550 resultobj = SWIG_From_int(static_cast< int >(result));
50551 return resultobj;
50552 fail:
50553 return NULL;
50554 }
50555
50556
50557 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50558 PyObject *resultobj = 0;
50559 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50560 int arg2 ;
50561 void *argp1 = 0 ;
50562 int res1 = 0 ;
50563 int val2 ;
50564 int ecode2 = 0 ;
50565 PyObject * obj0 = 0 ;
50566 PyObject * obj1 = 0 ;
50567 char * kwnames[] = {
50568 (char *) "self",(char *) "row", NULL
50569 };
50570
50571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50573 if (!SWIG_IsOK(res1)) {
50574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50575 }
50576 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50577 ecode2 = SWIG_AsVal_int(obj1, &val2);
50578 if (!SWIG_IsOK(ecode2)) {
50579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50580 }
50581 arg2 = static_cast< int >(val2);
50582 {
50583 PyThreadState* __tstate = wxPyBeginAllowThreads();
50584 (arg1)->SetRow(arg2);
50585 wxPyEndAllowThreads(__tstate);
50586 if (PyErr_Occurred()) SWIG_fail;
50587 }
50588 resultobj = SWIG_Py_Void();
50589 return resultobj;
50590 fail:
50591 return NULL;
50592 }
50593
50594
50595 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50596 PyObject *resultobj = 0;
50597 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50598 int arg2 ;
50599 void *argp1 = 0 ;
50600 int res1 = 0 ;
50601 int val2 ;
50602 int ecode2 = 0 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 char * kwnames[] = {
50606 (char *) "self",(char *) "col", NULL
50607 };
50608
50609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50613 }
50614 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50615 ecode2 = SWIG_AsVal_int(obj1, &val2);
50616 if (!SWIG_IsOK(ecode2)) {
50617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50618 }
50619 arg2 = static_cast< int >(val2);
50620 {
50621 PyThreadState* __tstate = wxPyBeginAllowThreads();
50622 (arg1)->SetCol(arg2);
50623 wxPyEndAllowThreads(__tstate);
50624 if (PyErr_Occurred()) SWIG_fail;
50625 }
50626 resultobj = SWIG_Py_Void();
50627 return resultobj;
50628 fail:
50629 return NULL;
50630 }
50631
50632
50633 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50634 PyObject *resultobj = 0;
50635 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50636 PyObject *arg2 = (PyObject *) 0 ;
50637 bool result;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 PyObject * obj0 = 0 ;
50641 PyObject * obj1 = 0 ;
50642 char * kwnames[] = {
50643 (char *) "self",(char *) "other", NULL
50644 };
50645
50646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50648 if (!SWIG_IsOK(res1)) {
50649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50650 }
50651 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50652 arg2 = obj1;
50653 {
50654 result = (bool)wxGBPosition___eq__(arg1,arg2);
50655 if (PyErr_Occurred()) SWIG_fail;
50656 }
50657 {
50658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50659 }
50660 return resultobj;
50661 fail:
50662 return NULL;
50663 }
50664
50665
50666 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50667 PyObject *resultobj = 0;
50668 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50669 PyObject *arg2 = (PyObject *) 0 ;
50670 bool result;
50671 void *argp1 = 0 ;
50672 int res1 = 0 ;
50673 PyObject * obj0 = 0 ;
50674 PyObject * obj1 = 0 ;
50675 char * kwnames[] = {
50676 (char *) "self",(char *) "other", NULL
50677 };
50678
50679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50681 if (!SWIG_IsOK(res1)) {
50682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50683 }
50684 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50685 arg2 = obj1;
50686 {
50687 result = (bool)wxGBPosition___ne__(arg1,arg2);
50688 if (PyErr_Occurred()) SWIG_fail;
50689 }
50690 {
50691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50692 }
50693 return resultobj;
50694 fail:
50695 return NULL;
50696 }
50697
50698
50699 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50700 PyObject *resultobj = 0;
50701 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50702 int arg2 = (int) 0 ;
50703 int arg3 = (int) 0 ;
50704 void *argp1 = 0 ;
50705 int res1 = 0 ;
50706 int val2 ;
50707 int ecode2 = 0 ;
50708 int val3 ;
50709 int ecode3 = 0 ;
50710 PyObject * obj0 = 0 ;
50711 PyObject * obj1 = 0 ;
50712 PyObject * obj2 = 0 ;
50713 char * kwnames[] = {
50714 (char *) "self",(char *) "row",(char *) "col", NULL
50715 };
50716
50717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50719 if (!SWIG_IsOK(res1)) {
50720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50721 }
50722 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50723 if (obj1) {
50724 ecode2 = SWIG_AsVal_int(obj1, &val2);
50725 if (!SWIG_IsOK(ecode2)) {
50726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50727 }
50728 arg2 = static_cast< int >(val2);
50729 }
50730 if (obj2) {
50731 ecode3 = SWIG_AsVal_int(obj2, &val3);
50732 if (!SWIG_IsOK(ecode3)) {
50733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50734 }
50735 arg3 = static_cast< int >(val3);
50736 }
50737 {
50738 PyThreadState* __tstate = wxPyBeginAllowThreads();
50739 wxGBPosition_Set(arg1,arg2,arg3);
50740 wxPyEndAllowThreads(__tstate);
50741 if (PyErr_Occurred()) SWIG_fail;
50742 }
50743 resultobj = SWIG_Py_Void();
50744 return resultobj;
50745 fail:
50746 return NULL;
50747 }
50748
50749
50750 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50751 PyObject *resultobj = 0;
50752 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50753 PyObject *result = 0 ;
50754 void *argp1 = 0 ;
50755 int res1 = 0 ;
50756 PyObject *swig_obj[1] ;
50757
50758 if (!args) SWIG_fail;
50759 swig_obj[0] = args;
50760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50761 if (!SWIG_IsOK(res1)) {
50762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50763 }
50764 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50765 {
50766 PyThreadState* __tstate = wxPyBeginAllowThreads();
50767 result = (PyObject *)wxGBPosition_Get(arg1);
50768 wxPyEndAllowThreads(__tstate);
50769 if (PyErr_Occurred()) SWIG_fail;
50770 }
50771 resultobj = result;
50772 return resultobj;
50773 fail:
50774 return NULL;
50775 }
50776
50777
50778 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50779 PyObject *obj;
50780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50781 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50782 return SWIG_Py_Void();
50783 }
50784
50785 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50786 return SWIG_Python_InitShadowInstance(args);
50787 }
50788
50789 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50790 PyObject *resultobj = 0;
50791 int arg1 = (int) 1 ;
50792 int arg2 = (int) 1 ;
50793 wxGBSpan *result = 0 ;
50794 int val1 ;
50795 int ecode1 = 0 ;
50796 int val2 ;
50797 int ecode2 = 0 ;
50798 PyObject * obj0 = 0 ;
50799 PyObject * obj1 = 0 ;
50800 char * kwnames[] = {
50801 (char *) "rowspan",(char *) "colspan", NULL
50802 };
50803
50804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50805 if (obj0) {
50806 ecode1 = SWIG_AsVal_int(obj0, &val1);
50807 if (!SWIG_IsOK(ecode1)) {
50808 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50809 }
50810 arg1 = static_cast< int >(val1);
50811 }
50812 if (obj1) {
50813 ecode2 = SWIG_AsVal_int(obj1, &val2);
50814 if (!SWIG_IsOK(ecode2)) {
50815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50816 }
50817 arg2 = static_cast< int >(val2);
50818 }
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50826 return resultobj;
50827 fail:
50828 return NULL;
50829 }
50830
50831
50832 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50833 PyObject *resultobj = 0;
50834 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50835 void *argp1 = 0 ;
50836 int res1 = 0 ;
50837 PyObject *swig_obj[1] ;
50838
50839 if (!args) SWIG_fail;
50840 swig_obj[0] = args;
50841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50842 if (!SWIG_IsOK(res1)) {
50843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50844 }
50845 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50846 {
50847 PyThreadState* __tstate = wxPyBeginAllowThreads();
50848 delete arg1;
50849
50850 wxPyEndAllowThreads(__tstate);
50851 if (PyErr_Occurred()) SWIG_fail;
50852 }
50853 resultobj = SWIG_Py_Void();
50854 return resultobj;
50855 fail:
50856 return NULL;
50857 }
50858
50859
50860 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50861 PyObject *resultobj = 0;
50862 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50863 int result;
50864 void *argp1 = 0 ;
50865 int res1 = 0 ;
50866 PyObject *swig_obj[1] ;
50867
50868 if (!args) SWIG_fail;
50869 swig_obj[0] = args;
50870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50871 if (!SWIG_IsOK(res1)) {
50872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50873 }
50874 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50875 {
50876 PyThreadState* __tstate = wxPyBeginAllowThreads();
50877 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50878 wxPyEndAllowThreads(__tstate);
50879 if (PyErr_Occurred()) SWIG_fail;
50880 }
50881 resultobj = SWIG_From_int(static_cast< int >(result));
50882 return resultobj;
50883 fail:
50884 return NULL;
50885 }
50886
50887
50888 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50889 PyObject *resultobj = 0;
50890 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50891 int result;
50892 void *argp1 = 0 ;
50893 int res1 = 0 ;
50894 PyObject *swig_obj[1] ;
50895
50896 if (!args) SWIG_fail;
50897 swig_obj[0] = args;
50898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50899 if (!SWIG_IsOK(res1)) {
50900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50901 }
50902 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50903 {
50904 PyThreadState* __tstate = wxPyBeginAllowThreads();
50905 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50906 wxPyEndAllowThreads(__tstate);
50907 if (PyErr_Occurred()) SWIG_fail;
50908 }
50909 resultobj = SWIG_From_int(static_cast< int >(result));
50910 return resultobj;
50911 fail:
50912 return NULL;
50913 }
50914
50915
50916 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50917 PyObject *resultobj = 0;
50918 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50919 int arg2 ;
50920 void *argp1 = 0 ;
50921 int res1 = 0 ;
50922 int val2 ;
50923 int ecode2 = 0 ;
50924 PyObject * obj0 = 0 ;
50925 PyObject * obj1 = 0 ;
50926 char * kwnames[] = {
50927 (char *) "self",(char *) "rowspan", NULL
50928 };
50929
50930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50932 if (!SWIG_IsOK(res1)) {
50933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50934 }
50935 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50936 ecode2 = SWIG_AsVal_int(obj1, &val2);
50937 if (!SWIG_IsOK(ecode2)) {
50938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50939 }
50940 arg2 = static_cast< int >(val2);
50941 {
50942 PyThreadState* __tstate = wxPyBeginAllowThreads();
50943 (arg1)->SetRowspan(arg2);
50944 wxPyEndAllowThreads(__tstate);
50945 if (PyErr_Occurred()) SWIG_fail;
50946 }
50947 resultobj = SWIG_Py_Void();
50948 return resultobj;
50949 fail:
50950 return NULL;
50951 }
50952
50953
50954 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50955 PyObject *resultobj = 0;
50956 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50957 int arg2 ;
50958 void *argp1 = 0 ;
50959 int res1 = 0 ;
50960 int val2 ;
50961 int ecode2 = 0 ;
50962 PyObject * obj0 = 0 ;
50963 PyObject * obj1 = 0 ;
50964 char * kwnames[] = {
50965 (char *) "self",(char *) "colspan", NULL
50966 };
50967
50968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50970 if (!SWIG_IsOK(res1)) {
50971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50972 }
50973 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50974 ecode2 = SWIG_AsVal_int(obj1, &val2);
50975 if (!SWIG_IsOK(ecode2)) {
50976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50977 }
50978 arg2 = static_cast< int >(val2);
50979 {
50980 PyThreadState* __tstate = wxPyBeginAllowThreads();
50981 (arg1)->SetColspan(arg2);
50982 wxPyEndAllowThreads(__tstate);
50983 if (PyErr_Occurred()) SWIG_fail;
50984 }
50985 resultobj = SWIG_Py_Void();
50986 return resultobj;
50987 fail:
50988 return NULL;
50989 }
50990
50991
50992 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50993 PyObject *resultobj = 0;
50994 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50995 PyObject *arg2 = (PyObject *) 0 ;
50996 bool result;
50997 void *argp1 = 0 ;
50998 int res1 = 0 ;
50999 PyObject * obj0 = 0 ;
51000 PyObject * obj1 = 0 ;
51001 char * kwnames[] = {
51002 (char *) "self",(char *) "other", NULL
51003 };
51004
51005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
51006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51007 if (!SWIG_IsOK(res1)) {
51008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51009 }
51010 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51011 arg2 = obj1;
51012 {
51013 result = (bool)wxGBSpan___eq__(arg1,arg2);
51014 if (PyErr_Occurred()) SWIG_fail;
51015 }
51016 {
51017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51018 }
51019 return resultobj;
51020 fail:
51021 return NULL;
51022 }
51023
51024
51025 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51026 PyObject *resultobj = 0;
51027 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51028 PyObject *arg2 = (PyObject *) 0 ;
51029 bool result;
51030 void *argp1 = 0 ;
51031 int res1 = 0 ;
51032 PyObject * obj0 = 0 ;
51033 PyObject * obj1 = 0 ;
51034 char * kwnames[] = {
51035 (char *) "self",(char *) "other", NULL
51036 };
51037
51038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
51039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51040 if (!SWIG_IsOK(res1)) {
51041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51042 }
51043 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51044 arg2 = obj1;
51045 {
51046 result = (bool)wxGBSpan___ne__(arg1,arg2);
51047 if (PyErr_Occurred()) SWIG_fail;
51048 }
51049 {
51050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51051 }
51052 return resultobj;
51053 fail:
51054 return NULL;
51055 }
51056
51057
51058 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51059 PyObject *resultobj = 0;
51060 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51061 int arg2 = (int) 1 ;
51062 int arg3 = (int) 1 ;
51063 void *argp1 = 0 ;
51064 int res1 = 0 ;
51065 int val2 ;
51066 int ecode2 = 0 ;
51067 int val3 ;
51068 int ecode3 = 0 ;
51069 PyObject * obj0 = 0 ;
51070 PyObject * obj1 = 0 ;
51071 PyObject * obj2 = 0 ;
51072 char * kwnames[] = {
51073 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
51074 };
51075
51076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51078 if (!SWIG_IsOK(res1)) {
51079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51080 }
51081 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51082 if (obj1) {
51083 ecode2 = SWIG_AsVal_int(obj1, &val2);
51084 if (!SWIG_IsOK(ecode2)) {
51085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
51086 }
51087 arg2 = static_cast< int >(val2);
51088 }
51089 if (obj2) {
51090 ecode3 = SWIG_AsVal_int(obj2, &val3);
51091 if (!SWIG_IsOK(ecode3)) {
51092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
51093 }
51094 arg3 = static_cast< int >(val3);
51095 }
51096 {
51097 PyThreadState* __tstate = wxPyBeginAllowThreads();
51098 wxGBSpan_Set(arg1,arg2,arg3);
51099 wxPyEndAllowThreads(__tstate);
51100 if (PyErr_Occurred()) SWIG_fail;
51101 }
51102 resultobj = SWIG_Py_Void();
51103 return resultobj;
51104 fail:
51105 return NULL;
51106 }
51107
51108
51109 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51110 PyObject *resultobj = 0;
51111 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
51112 PyObject *result = 0 ;
51113 void *argp1 = 0 ;
51114 int res1 = 0 ;
51115 PyObject *swig_obj[1] ;
51116
51117 if (!args) SWIG_fail;
51118 swig_obj[0] = args;
51119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
51120 if (!SWIG_IsOK(res1)) {
51121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
51122 }
51123 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
51124 {
51125 PyThreadState* __tstate = wxPyBeginAllowThreads();
51126 result = (PyObject *)wxGBSpan_Get(arg1);
51127 wxPyEndAllowThreads(__tstate);
51128 if (PyErr_Occurred()) SWIG_fail;
51129 }
51130 resultobj = result;
51131 return resultobj;
51132 fail:
51133 return NULL;
51134 }
51135
51136
51137 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51138 PyObject *obj;
51139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51140 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
51141 return SWIG_Py_Void();
51142 }
51143
51144 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51145 return SWIG_Python_InitShadowInstance(args);
51146 }
51147
51148 SWIGINTERN int DefaultSpan_set(PyObject *) {
51149 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
51150 return 1;
51151 }
51152
51153
51154 SWIGINTERN PyObject *DefaultSpan_get(void) {
51155 PyObject *pyobj = 0;
51156
51157 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
51158 return pyobj;
51159 }
51160
51161
51162 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51163 PyObject *resultobj = 0;
51164 wxGBSizerItem *result = 0 ;
51165
51166 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
51167 {
51168 PyThreadState* __tstate = wxPyBeginAllowThreads();
51169 result = (wxGBSizerItem *)new wxGBSizerItem();
51170 wxPyEndAllowThreads(__tstate);
51171 if (PyErr_Occurred()) SWIG_fail;
51172 }
51173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
51174 return resultobj;
51175 fail:
51176 return NULL;
51177 }
51178
51179
51180 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51181 PyObject *resultobj = 0;
51182 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51183 void *argp1 = 0 ;
51184 int res1 = 0 ;
51185 PyObject *swig_obj[1] ;
51186
51187 if (!args) SWIG_fail;
51188 swig_obj[0] = args;
51189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51190 if (!SWIG_IsOK(res1)) {
51191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51192 }
51193 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51194 {
51195 PyThreadState* __tstate = wxPyBeginAllowThreads();
51196 delete arg1;
51197
51198 wxPyEndAllowThreads(__tstate);
51199 if (PyErr_Occurred()) SWIG_fail;
51200 }
51201 resultobj = SWIG_Py_Void();
51202 return resultobj;
51203 fail:
51204 return NULL;
51205 }
51206
51207
51208 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51209 PyObject *resultobj = 0;
51210 wxWindow *arg1 = (wxWindow *) 0 ;
51211 wxGBPosition *arg2 = 0 ;
51212 wxGBSpan *arg3 = 0 ;
51213 int arg4 ;
51214 int arg5 ;
51215 PyObject *arg6 = (PyObject *) NULL ;
51216 wxGBSizerItem *result = 0 ;
51217 void *argp1 = 0 ;
51218 int res1 = 0 ;
51219 wxGBPosition temp2 ;
51220 wxGBSpan temp3 ;
51221 int val4 ;
51222 int ecode4 = 0 ;
51223 int val5 ;
51224 int ecode5 = 0 ;
51225 PyObject * obj0 = 0 ;
51226 PyObject * obj1 = 0 ;
51227 PyObject * obj2 = 0 ;
51228 PyObject * obj3 = 0 ;
51229 PyObject * obj4 = 0 ;
51230 PyObject * obj5 = 0 ;
51231 char * kwnames[] = {
51232 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51233 };
51234
51235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
51237 if (!SWIG_IsOK(res1)) {
51238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
51239 }
51240 arg1 = reinterpret_cast< wxWindow * >(argp1);
51241 {
51242 arg2 = &temp2;
51243 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51244 }
51245 {
51246 arg3 = &temp3;
51247 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51248 }
51249 ecode4 = SWIG_AsVal_int(obj3, &val4);
51250 if (!SWIG_IsOK(ecode4)) {
51251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
51252 }
51253 arg4 = static_cast< int >(val4);
51254 ecode5 = SWIG_AsVal_int(obj4, &val5);
51255 if (!SWIG_IsOK(ecode5)) {
51256 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
51257 }
51258 arg5 = static_cast< int >(val5);
51259 if (obj5) {
51260 arg6 = obj5;
51261 }
51262 {
51263 PyThreadState* __tstate = wxPyBeginAllowThreads();
51264 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51265 wxPyEndAllowThreads(__tstate);
51266 if (PyErr_Occurred()) SWIG_fail;
51267 }
51268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51269 return resultobj;
51270 fail:
51271 return NULL;
51272 }
51273
51274
51275 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51276 PyObject *resultobj = 0;
51277 wxSizer *arg1 = (wxSizer *) 0 ;
51278 wxGBPosition *arg2 = 0 ;
51279 wxGBSpan *arg3 = 0 ;
51280 int arg4 ;
51281 int arg5 ;
51282 PyObject *arg6 = (PyObject *) NULL ;
51283 wxGBSizerItem *result = 0 ;
51284 int res1 = 0 ;
51285 wxGBPosition temp2 ;
51286 wxGBSpan temp3 ;
51287 int val4 ;
51288 int ecode4 = 0 ;
51289 int val5 ;
51290 int ecode5 = 0 ;
51291 PyObject * obj0 = 0 ;
51292 PyObject * obj1 = 0 ;
51293 PyObject * obj2 = 0 ;
51294 PyObject * obj3 = 0 ;
51295 PyObject * obj4 = 0 ;
51296 PyObject * obj5 = 0 ;
51297 char * kwnames[] = {
51298 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51299 };
51300
51301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51302 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51303 if (!SWIG_IsOK(res1)) {
51304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51305 }
51306 {
51307 arg2 = &temp2;
51308 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51309 }
51310 {
51311 arg3 = &temp3;
51312 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51313 }
51314 ecode4 = SWIG_AsVal_int(obj3, &val4);
51315 if (!SWIG_IsOK(ecode4)) {
51316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
51317 }
51318 arg4 = static_cast< int >(val4);
51319 ecode5 = SWIG_AsVal_int(obj4, &val5);
51320 if (!SWIG_IsOK(ecode5)) {
51321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
51322 }
51323 arg5 = static_cast< int >(val5);
51324 if (obj5) {
51325 arg6 = obj5;
51326 }
51327 {
51328 PyThreadState* __tstate = wxPyBeginAllowThreads();
51329 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
51330 wxPyEndAllowThreads(__tstate);
51331 if (PyErr_Occurred()) SWIG_fail;
51332 }
51333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51334 return resultobj;
51335 fail:
51336 return NULL;
51337 }
51338
51339
51340 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51341 PyObject *resultobj = 0;
51342 int arg1 ;
51343 int arg2 ;
51344 wxGBPosition *arg3 = 0 ;
51345 wxGBSpan *arg4 = 0 ;
51346 int arg5 ;
51347 int arg6 ;
51348 PyObject *arg7 = (PyObject *) NULL ;
51349 wxGBSizerItem *result = 0 ;
51350 int val1 ;
51351 int ecode1 = 0 ;
51352 int val2 ;
51353 int ecode2 = 0 ;
51354 wxGBPosition temp3 ;
51355 wxGBSpan temp4 ;
51356 int val5 ;
51357 int ecode5 = 0 ;
51358 int val6 ;
51359 int ecode6 = 0 ;
51360 PyObject * obj0 = 0 ;
51361 PyObject * obj1 = 0 ;
51362 PyObject * obj2 = 0 ;
51363 PyObject * obj3 = 0 ;
51364 PyObject * obj4 = 0 ;
51365 PyObject * obj5 = 0 ;
51366 PyObject * obj6 = 0 ;
51367 char * kwnames[] = {
51368 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51369 };
51370
51371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51372 ecode1 = SWIG_AsVal_int(obj0, &val1);
51373 if (!SWIG_IsOK(ecode1)) {
51374 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
51375 }
51376 arg1 = static_cast< int >(val1);
51377 ecode2 = SWIG_AsVal_int(obj1, &val2);
51378 if (!SWIG_IsOK(ecode2)) {
51379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
51380 }
51381 arg2 = static_cast< int >(val2);
51382 {
51383 arg3 = &temp3;
51384 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51385 }
51386 {
51387 arg4 = &temp4;
51388 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51389 }
51390 ecode5 = SWIG_AsVal_int(obj4, &val5);
51391 if (!SWIG_IsOK(ecode5)) {
51392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
51393 }
51394 arg5 = static_cast< int >(val5);
51395 ecode6 = SWIG_AsVal_int(obj5, &val6);
51396 if (!SWIG_IsOK(ecode6)) {
51397 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
51398 }
51399 arg6 = static_cast< int >(val6);
51400 if (obj6) {
51401 arg7 = obj6;
51402 }
51403 {
51404 PyThreadState* __tstate = wxPyBeginAllowThreads();
51405 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51406 wxPyEndAllowThreads(__tstate);
51407 if (PyErr_Occurred()) SWIG_fail;
51408 }
51409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
51410 return resultobj;
51411 fail:
51412 return NULL;
51413 }
51414
51415
51416 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51417 PyObject *resultobj = 0;
51418 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51419 wxGBPosition result;
51420 void *argp1 = 0 ;
51421 int res1 = 0 ;
51422 PyObject *swig_obj[1] ;
51423
51424 if (!args) SWIG_fail;
51425 swig_obj[0] = args;
51426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51427 if (!SWIG_IsOK(res1)) {
51428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51429 }
51430 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51431 {
51432 PyThreadState* __tstate = wxPyBeginAllowThreads();
51433 result = ((wxGBSizerItem const *)arg1)->GetPos();
51434 wxPyEndAllowThreads(__tstate);
51435 if (PyErr_Occurred()) SWIG_fail;
51436 }
51437 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51438 return resultobj;
51439 fail:
51440 return NULL;
51441 }
51442
51443
51444 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51445 PyObject *resultobj = 0;
51446 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51447 wxGBSpan result;
51448 void *argp1 = 0 ;
51449 int res1 = 0 ;
51450 PyObject *swig_obj[1] ;
51451
51452 if (!args) SWIG_fail;
51453 swig_obj[0] = args;
51454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51455 if (!SWIG_IsOK(res1)) {
51456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51457 }
51458 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51459 {
51460 PyThreadState* __tstate = wxPyBeginAllowThreads();
51461 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51462 wxPyEndAllowThreads(__tstate);
51463 if (PyErr_Occurred()) SWIG_fail;
51464 }
51465 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51466 return resultobj;
51467 fail:
51468 return NULL;
51469 }
51470
51471
51472 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51473 PyObject *resultobj = 0;
51474 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51475 wxGBPosition *arg2 = 0 ;
51476 bool result;
51477 void *argp1 = 0 ;
51478 int res1 = 0 ;
51479 wxGBPosition temp2 ;
51480 PyObject * obj0 = 0 ;
51481 PyObject * obj1 = 0 ;
51482 char * kwnames[] = {
51483 (char *) "self",(char *) "pos", NULL
51484 };
51485
51486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51488 if (!SWIG_IsOK(res1)) {
51489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51490 }
51491 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51492 {
51493 arg2 = &temp2;
51494 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51495 }
51496 {
51497 PyThreadState* __tstate = wxPyBeginAllowThreads();
51498 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51499 wxPyEndAllowThreads(__tstate);
51500 if (PyErr_Occurred()) SWIG_fail;
51501 }
51502 {
51503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51504 }
51505 return resultobj;
51506 fail:
51507 return NULL;
51508 }
51509
51510
51511 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51512 PyObject *resultobj = 0;
51513 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51514 wxGBSpan *arg2 = 0 ;
51515 bool result;
51516 void *argp1 = 0 ;
51517 int res1 = 0 ;
51518 wxGBSpan temp2 ;
51519 PyObject * obj0 = 0 ;
51520 PyObject * obj1 = 0 ;
51521 char * kwnames[] = {
51522 (char *) "self",(char *) "span", NULL
51523 };
51524
51525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51527 if (!SWIG_IsOK(res1)) {
51528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51529 }
51530 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51531 {
51532 arg2 = &temp2;
51533 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51534 }
51535 {
51536 PyThreadState* __tstate = wxPyBeginAllowThreads();
51537 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51538 wxPyEndAllowThreads(__tstate);
51539 if (PyErr_Occurred()) SWIG_fail;
51540 }
51541 {
51542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51543 }
51544 return resultobj;
51545 fail:
51546 return NULL;
51547 }
51548
51549
51550 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51551 PyObject *resultobj = 0;
51552 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51553 wxGBSizerItem *arg2 = 0 ;
51554 bool result;
51555 void *argp1 = 0 ;
51556 int res1 = 0 ;
51557 void *argp2 = 0 ;
51558 int res2 = 0 ;
51559 PyObject * obj0 = 0 ;
51560 PyObject * obj1 = 0 ;
51561 char * kwnames[] = {
51562 (char *) "self",(char *) "other", NULL
51563 };
51564
51565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51567 if (!SWIG_IsOK(res1)) {
51568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51569 }
51570 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51571 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51572 if (!SWIG_IsOK(res2)) {
51573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51574 }
51575 if (!argp2) {
51576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51577 }
51578 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51579 {
51580 PyThreadState* __tstate = wxPyBeginAllowThreads();
51581 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51582 wxPyEndAllowThreads(__tstate);
51583 if (PyErr_Occurred()) SWIG_fail;
51584 }
51585 {
51586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51587 }
51588 return resultobj;
51589 fail:
51590 return NULL;
51591 }
51592
51593
51594 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51595 PyObject *resultobj = 0;
51596 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51597 wxGBPosition *arg2 = 0 ;
51598 wxGBSpan *arg3 = 0 ;
51599 bool result;
51600 void *argp1 = 0 ;
51601 int res1 = 0 ;
51602 wxGBPosition temp2 ;
51603 wxGBSpan temp3 ;
51604 PyObject * obj0 = 0 ;
51605 PyObject * obj1 = 0 ;
51606 PyObject * obj2 = 0 ;
51607 char * kwnames[] = {
51608 (char *) "self",(char *) "pos",(char *) "span", NULL
51609 };
51610
51611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51613 if (!SWIG_IsOK(res1)) {
51614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51615 }
51616 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51617 {
51618 arg2 = &temp2;
51619 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51620 }
51621 {
51622 arg3 = &temp3;
51623 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51624 }
51625 {
51626 PyThreadState* __tstate = wxPyBeginAllowThreads();
51627 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51628 wxPyEndAllowThreads(__tstate);
51629 if (PyErr_Occurred()) SWIG_fail;
51630 }
51631 {
51632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51633 }
51634 return resultobj;
51635 fail:
51636 return NULL;
51637 }
51638
51639
51640 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51641 PyObject *resultobj = 0;
51642 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51643 wxGBPosition result;
51644 void *argp1 = 0 ;
51645 int res1 = 0 ;
51646 PyObject *swig_obj[1] ;
51647
51648 if (!args) SWIG_fail;
51649 swig_obj[0] = args;
51650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51651 if (!SWIG_IsOK(res1)) {
51652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51653 }
51654 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51655 {
51656 PyThreadState* __tstate = wxPyBeginAllowThreads();
51657 result = wxGBSizerItem_GetEndPos(arg1);
51658 wxPyEndAllowThreads(__tstate);
51659 if (PyErr_Occurred()) SWIG_fail;
51660 }
51661 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51662 return resultobj;
51663 fail:
51664 return NULL;
51665 }
51666
51667
51668 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51669 PyObject *resultobj = 0;
51670 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51671 wxGridBagSizer *result = 0 ;
51672 void *argp1 = 0 ;
51673 int res1 = 0 ;
51674 PyObject *swig_obj[1] ;
51675
51676 if (!args) SWIG_fail;
51677 swig_obj[0] = args;
51678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51679 if (!SWIG_IsOK(res1)) {
51680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51681 }
51682 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51683 {
51684 PyThreadState* __tstate = wxPyBeginAllowThreads();
51685 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51686 wxPyEndAllowThreads(__tstate);
51687 if (PyErr_Occurred()) SWIG_fail;
51688 }
51689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51690 return resultobj;
51691 fail:
51692 return NULL;
51693 }
51694
51695
51696 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51697 PyObject *resultobj = 0;
51698 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51699 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51700 void *argp1 = 0 ;
51701 int res1 = 0 ;
51702 void *argp2 = 0 ;
51703 int res2 = 0 ;
51704 PyObject * obj0 = 0 ;
51705 PyObject * obj1 = 0 ;
51706 char * kwnames[] = {
51707 (char *) "self",(char *) "sizer", NULL
51708 };
51709
51710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51712 if (!SWIG_IsOK(res1)) {
51713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51714 }
51715 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51716 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51717 if (!SWIG_IsOK(res2)) {
51718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51719 }
51720 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 (arg1)->SetGBSizer(arg2);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 resultobj = SWIG_Py_Void();
51728 return resultobj;
51729 fail:
51730 return NULL;
51731 }
51732
51733
51734 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51735 PyObject *obj;
51736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51737 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51738 return SWIG_Py_Void();
51739 }
51740
51741 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51742 return SWIG_Python_InitShadowInstance(args);
51743 }
51744
51745 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51746 PyObject *resultobj = 0;
51747 int arg1 = (int) 0 ;
51748 int arg2 = (int) 0 ;
51749 wxGridBagSizer *result = 0 ;
51750 int val1 ;
51751 int ecode1 = 0 ;
51752 int val2 ;
51753 int ecode2 = 0 ;
51754 PyObject * obj0 = 0 ;
51755 PyObject * obj1 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "vgap",(char *) "hgap", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51761 if (obj0) {
51762 ecode1 = SWIG_AsVal_int(obj0, &val1);
51763 if (!SWIG_IsOK(ecode1)) {
51764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51765 }
51766 arg1 = static_cast< int >(val1);
51767 }
51768 if (obj1) {
51769 ecode2 = SWIG_AsVal_int(obj1, &val2);
51770 if (!SWIG_IsOK(ecode2)) {
51771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51772 }
51773 arg2 = static_cast< int >(val2);
51774 }
51775 {
51776 PyThreadState* __tstate = wxPyBeginAllowThreads();
51777 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51778 wxPyEndAllowThreads(__tstate);
51779 if (PyErr_Occurred()) SWIG_fail;
51780 }
51781 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51782 return resultobj;
51783 fail:
51784 return NULL;
51785 }
51786
51787
51788 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51789 PyObject *resultobj = 0;
51790 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51791 PyObject *arg2 = (PyObject *) 0 ;
51792 wxGBPosition *arg3 = 0 ;
51793 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51794 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51795 int arg5 = (int) 0 ;
51796 int arg6 = (int) 0 ;
51797 PyObject *arg7 = (PyObject *) NULL ;
51798 wxGBSizerItem *result = 0 ;
51799 void *argp1 = 0 ;
51800 int res1 = 0 ;
51801 wxGBPosition temp3 ;
51802 wxGBSpan temp4 ;
51803 int val5 ;
51804 int ecode5 = 0 ;
51805 int val6 ;
51806 int ecode6 = 0 ;
51807 PyObject * obj0 = 0 ;
51808 PyObject * obj1 = 0 ;
51809 PyObject * obj2 = 0 ;
51810 PyObject * obj3 = 0 ;
51811 PyObject * obj4 = 0 ;
51812 PyObject * obj5 = 0 ;
51813 PyObject * obj6 = 0 ;
51814 char * kwnames[] = {
51815 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51816 };
51817
51818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51820 if (!SWIG_IsOK(res1)) {
51821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51822 }
51823 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51824 arg2 = obj1;
51825 {
51826 arg3 = &temp3;
51827 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51828 }
51829 if (obj3) {
51830 {
51831 arg4 = &temp4;
51832 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51833 }
51834 }
51835 if (obj4) {
51836 ecode5 = SWIG_AsVal_int(obj4, &val5);
51837 if (!SWIG_IsOK(ecode5)) {
51838 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51839 }
51840 arg5 = static_cast< int >(val5);
51841 }
51842 if (obj5) {
51843 ecode6 = SWIG_AsVal_int(obj5, &val6);
51844 if (!SWIG_IsOK(ecode6)) {
51845 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51846 }
51847 arg6 = static_cast< int >(val6);
51848 }
51849 if (obj6) {
51850 arg7 = obj6;
51851 }
51852 {
51853 PyThreadState* __tstate = wxPyBeginAllowThreads();
51854 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51855 wxPyEndAllowThreads(__tstate);
51856 if (PyErr_Occurred()) SWIG_fail;
51857 }
51858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51859 return resultobj;
51860 fail:
51861 return NULL;
51862 }
51863
51864
51865 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51866 PyObject *resultobj = 0;
51867 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51868 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51869 wxGBSizerItem *result = 0 ;
51870 void *argp1 = 0 ;
51871 int res1 = 0 ;
51872 int res2 = 0 ;
51873 PyObject * obj0 = 0 ;
51874 PyObject * obj1 = 0 ;
51875 char * kwnames[] = {
51876 (char *) "self",(char *) "item", NULL
51877 };
51878
51879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51881 if (!SWIG_IsOK(res1)) {
51882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51883 }
51884 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51885 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51886 if (!SWIG_IsOK(res2)) {
51887 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51888 }
51889 {
51890 PyThreadState* __tstate = wxPyBeginAllowThreads();
51891 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51892 wxPyEndAllowThreads(__tstate);
51893 if (PyErr_Occurred()) SWIG_fail;
51894 }
51895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51896 return resultobj;
51897 fail:
51898 return NULL;
51899 }
51900
51901
51902 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51903 PyObject *resultobj = 0;
51904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51905 int arg2 ;
51906 int arg3 ;
51907 wxSize result;
51908 void *argp1 = 0 ;
51909 int res1 = 0 ;
51910 int val2 ;
51911 int ecode2 = 0 ;
51912 int val3 ;
51913 int ecode3 = 0 ;
51914 PyObject * obj0 = 0 ;
51915 PyObject * obj1 = 0 ;
51916 PyObject * obj2 = 0 ;
51917 char * kwnames[] = {
51918 (char *) "self",(char *) "row",(char *) "col", NULL
51919 };
51920
51921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51923 if (!SWIG_IsOK(res1)) {
51924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51925 }
51926 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51927 ecode2 = SWIG_AsVal_int(obj1, &val2);
51928 if (!SWIG_IsOK(ecode2)) {
51929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51930 }
51931 arg2 = static_cast< int >(val2);
51932 ecode3 = SWIG_AsVal_int(obj2, &val3);
51933 if (!SWIG_IsOK(ecode3)) {
51934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51935 }
51936 arg3 = static_cast< int >(val3);
51937 {
51938 PyThreadState* __tstate = wxPyBeginAllowThreads();
51939 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51940 wxPyEndAllowThreads(__tstate);
51941 if (PyErr_Occurred()) SWIG_fail;
51942 }
51943 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51944 return resultobj;
51945 fail:
51946 return NULL;
51947 }
51948
51949
51950 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51951 PyObject *resultobj = 0;
51952 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51953 wxSize result;
51954 void *argp1 = 0 ;
51955 int res1 = 0 ;
51956 PyObject *swig_obj[1] ;
51957
51958 if (!args) SWIG_fail;
51959 swig_obj[0] = args;
51960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51961 if (!SWIG_IsOK(res1)) {
51962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51963 }
51964 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51965 {
51966 PyThreadState* __tstate = wxPyBeginAllowThreads();
51967 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51968 wxPyEndAllowThreads(__tstate);
51969 if (PyErr_Occurred()) SWIG_fail;
51970 }
51971 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51972 return resultobj;
51973 fail:
51974 return NULL;
51975 }
51976
51977
51978 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51979 PyObject *resultobj = 0;
51980 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51981 wxSize *arg2 = 0 ;
51982 void *argp1 = 0 ;
51983 int res1 = 0 ;
51984 wxSize temp2 ;
51985 PyObject * obj0 = 0 ;
51986 PyObject * obj1 = 0 ;
51987 char * kwnames[] = {
51988 (char *) "self",(char *) "sz", NULL
51989 };
51990
51991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51993 if (!SWIG_IsOK(res1)) {
51994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51995 }
51996 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51997 {
51998 arg2 = &temp2;
51999 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52000 }
52001 {
52002 PyThreadState* __tstate = wxPyBeginAllowThreads();
52003 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
52004 wxPyEndAllowThreads(__tstate);
52005 if (PyErr_Occurred()) SWIG_fail;
52006 }
52007 resultobj = SWIG_Py_Void();
52008 return resultobj;
52009 fail:
52010 return NULL;
52011 }
52012
52013
52014 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52015 PyObject *resultobj = 0;
52016 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52017 wxWindow *arg2 = (wxWindow *) 0 ;
52018 wxGBPosition result;
52019 void *argp1 = 0 ;
52020 int res1 = 0 ;
52021 void *argp2 = 0 ;
52022 int res2 = 0 ;
52023
52024 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52028 }
52029 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52030 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52031 if (!SWIG_IsOK(res2)) {
52032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52033 }
52034 arg2 = reinterpret_cast< wxWindow * >(argp2);
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 result = (arg1)->GetItemPosition(arg2);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52042 return resultobj;
52043 fail:
52044 return NULL;
52045 }
52046
52047
52048 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52049 PyObject *resultobj = 0;
52050 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52051 wxSizer *arg2 = (wxSizer *) 0 ;
52052 wxGBPosition result;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 void *argp2 = 0 ;
52056 int res2 = 0 ;
52057
52058 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52060 if (!SWIG_IsOK(res1)) {
52061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52062 }
52063 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52064 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52065 if (!SWIG_IsOK(res2)) {
52066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52067 }
52068 arg2 = reinterpret_cast< wxSizer * >(argp2);
52069 {
52070 PyThreadState* __tstate = wxPyBeginAllowThreads();
52071 result = (arg1)->GetItemPosition(arg2);
52072 wxPyEndAllowThreads(__tstate);
52073 if (PyErr_Occurred()) SWIG_fail;
52074 }
52075 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52076 return resultobj;
52077 fail:
52078 return NULL;
52079 }
52080
52081
52082 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52083 PyObject *resultobj = 0;
52084 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52085 size_t arg2 ;
52086 wxGBPosition result;
52087 void *argp1 = 0 ;
52088 int res1 = 0 ;
52089 size_t val2 ;
52090 int ecode2 = 0 ;
52091
52092 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52096 }
52097 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52098 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52099 if (!SWIG_IsOK(ecode2)) {
52100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52101 }
52102 arg2 = static_cast< size_t >(val2);
52103 {
52104 PyThreadState* __tstate = wxPyBeginAllowThreads();
52105 result = (arg1)->GetItemPosition(arg2);
52106 wxPyEndAllowThreads(__tstate);
52107 if (PyErr_Occurred()) SWIG_fail;
52108 }
52109 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
52110 return resultobj;
52111 fail:
52112 return NULL;
52113 }
52114
52115
52116 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
52117 int argc;
52118 PyObject *argv[3];
52119
52120 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
52121 --argc;
52122 if (argc == 2) {
52123 int _v = 0;
52124 {
52125 void *vptr = 0;
52126 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52127 _v = SWIG_CheckState(res);
52128 }
52129 if (!_v) goto check_1;
52130 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
52131 }
52132 check_1:
52133
52134 if (argc == 2) {
52135 int _v = 0;
52136 {
52137 void *vptr = 0;
52138 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52139 _v = SWIG_CheckState(res);
52140 }
52141 if (!_v) goto check_2;
52142 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
52143 }
52144 check_2:
52145
52146 if (argc == 2) {
52147 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
52148 }
52149
52150 fail:
52151 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
52152 return NULL;
52153 }
52154
52155
52156 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52157 PyObject *resultobj = 0;
52158 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52159 wxWindow *arg2 = (wxWindow *) 0 ;
52160 wxGBPosition *arg3 = 0 ;
52161 bool result;
52162 void *argp1 = 0 ;
52163 int res1 = 0 ;
52164 void *argp2 = 0 ;
52165 int res2 = 0 ;
52166 wxGBPosition temp3 ;
52167
52168 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52170 if (!SWIG_IsOK(res1)) {
52171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52172 }
52173 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52174 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52175 if (!SWIG_IsOK(res2)) {
52176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
52177 }
52178 arg2 = reinterpret_cast< wxWindow * >(argp2);
52179 {
52180 arg3 = &temp3;
52181 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52182 }
52183 {
52184 PyThreadState* __tstate = wxPyBeginAllowThreads();
52185 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52186 wxPyEndAllowThreads(__tstate);
52187 if (PyErr_Occurred()) SWIG_fail;
52188 }
52189 {
52190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52191 }
52192 return resultobj;
52193 fail:
52194 return NULL;
52195 }
52196
52197
52198 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52199 PyObject *resultobj = 0;
52200 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52201 wxSizer *arg2 = (wxSizer *) 0 ;
52202 wxGBPosition *arg3 = 0 ;
52203 bool result;
52204 void *argp1 = 0 ;
52205 int res1 = 0 ;
52206 void *argp2 = 0 ;
52207 int res2 = 0 ;
52208 wxGBPosition temp3 ;
52209
52210 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52212 if (!SWIG_IsOK(res1)) {
52213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52214 }
52215 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52216 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52217 if (!SWIG_IsOK(res2)) {
52218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
52219 }
52220 arg2 = reinterpret_cast< wxSizer * >(argp2);
52221 {
52222 arg3 = &temp3;
52223 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52224 }
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 {
52232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52233 }
52234 return resultobj;
52235 fail:
52236 return NULL;
52237 }
52238
52239
52240 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52241 PyObject *resultobj = 0;
52242 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52243 size_t arg2 ;
52244 wxGBPosition *arg3 = 0 ;
52245 bool result;
52246 void *argp1 = 0 ;
52247 int res1 = 0 ;
52248 size_t val2 ;
52249 int ecode2 = 0 ;
52250 wxGBPosition temp3 ;
52251
52252 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52254 if (!SWIG_IsOK(res1)) {
52255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52256 }
52257 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52258 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52259 if (!SWIG_IsOK(ecode2)) {
52260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
52261 }
52262 arg2 = static_cast< size_t >(val2);
52263 {
52264 arg3 = &temp3;
52265 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
52266 }
52267 {
52268 PyThreadState* __tstate = wxPyBeginAllowThreads();
52269 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
52270 wxPyEndAllowThreads(__tstate);
52271 if (PyErr_Occurred()) SWIG_fail;
52272 }
52273 {
52274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52275 }
52276 return resultobj;
52277 fail:
52278 return NULL;
52279 }
52280
52281
52282 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
52283 int argc;
52284 PyObject *argv[4];
52285
52286 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
52287 --argc;
52288 if (argc == 3) {
52289 int _v = 0;
52290 {
52291 void *vptr = 0;
52292 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52293 _v = SWIG_CheckState(res);
52294 }
52295 if (!_v) goto check_1;
52296 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
52297 }
52298 check_1:
52299
52300 if (argc == 3) {
52301 int _v = 0;
52302 {
52303 void *vptr = 0;
52304 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52305 _v = SWIG_CheckState(res);
52306 }
52307 if (!_v) goto check_2;
52308 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
52309 }
52310 check_2:
52311
52312 if (argc == 3) {
52313 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
52314 }
52315
52316 fail:
52317 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
52318 return NULL;
52319 }
52320
52321
52322 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52323 PyObject *resultobj = 0;
52324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52325 wxWindow *arg2 = (wxWindow *) 0 ;
52326 wxGBSpan result;
52327 void *argp1 = 0 ;
52328 int res1 = 0 ;
52329 void *argp2 = 0 ;
52330 int res2 = 0 ;
52331
52332 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52334 if (!SWIG_IsOK(res1)) {
52335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52336 }
52337 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52338 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52339 if (!SWIG_IsOK(res2)) {
52340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52341 }
52342 arg2 = reinterpret_cast< wxWindow * >(argp2);
52343 {
52344 PyThreadState* __tstate = wxPyBeginAllowThreads();
52345 result = (arg1)->GetItemSpan(arg2);
52346 wxPyEndAllowThreads(__tstate);
52347 if (PyErr_Occurred()) SWIG_fail;
52348 }
52349 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52350 return resultobj;
52351 fail:
52352 return NULL;
52353 }
52354
52355
52356 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52357 PyObject *resultobj = 0;
52358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52359 wxSizer *arg2 = (wxSizer *) 0 ;
52360 wxGBSpan result;
52361 void *argp1 = 0 ;
52362 int res1 = 0 ;
52363 void *argp2 = 0 ;
52364 int res2 = 0 ;
52365
52366 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52370 }
52371 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52372 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52373 if (!SWIG_IsOK(res2)) {
52374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52375 }
52376 arg2 = reinterpret_cast< wxSizer * >(argp2);
52377 {
52378 PyThreadState* __tstate = wxPyBeginAllowThreads();
52379 result = (arg1)->GetItemSpan(arg2);
52380 wxPyEndAllowThreads(__tstate);
52381 if (PyErr_Occurred()) SWIG_fail;
52382 }
52383 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52384 return resultobj;
52385 fail:
52386 return NULL;
52387 }
52388
52389
52390 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52391 PyObject *resultobj = 0;
52392 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52393 size_t arg2 ;
52394 wxGBSpan result;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 size_t val2 ;
52398 int ecode2 = 0 ;
52399
52400 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52402 if (!SWIG_IsOK(res1)) {
52403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52404 }
52405 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52406 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52407 if (!SWIG_IsOK(ecode2)) {
52408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52409 }
52410 arg2 = static_cast< size_t >(val2);
52411 {
52412 PyThreadState* __tstate = wxPyBeginAllowThreads();
52413 result = (arg1)->GetItemSpan(arg2);
52414 wxPyEndAllowThreads(__tstate);
52415 if (PyErr_Occurred()) SWIG_fail;
52416 }
52417 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
52418 return resultobj;
52419 fail:
52420 return NULL;
52421 }
52422
52423
52424 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
52425 int argc;
52426 PyObject *argv[3];
52427
52428 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
52429 --argc;
52430 if (argc == 2) {
52431 int _v = 0;
52432 {
52433 void *vptr = 0;
52434 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52435 _v = SWIG_CheckState(res);
52436 }
52437 if (!_v) goto check_1;
52438 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
52439 }
52440 check_1:
52441
52442 if (argc == 2) {
52443 int _v = 0;
52444 {
52445 void *vptr = 0;
52446 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52447 _v = SWIG_CheckState(res);
52448 }
52449 if (!_v) goto check_2;
52450 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52451 }
52452 check_2:
52453
52454 if (argc == 2) {
52455 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52456 }
52457
52458 fail:
52459 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52460 return NULL;
52461 }
52462
52463
52464 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52465 PyObject *resultobj = 0;
52466 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52467 wxWindow *arg2 = (wxWindow *) 0 ;
52468 wxGBSpan *arg3 = 0 ;
52469 bool result;
52470 void *argp1 = 0 ;
52471 int res1 = 0 ;
52472 void *argp2 = 0 ;
52473 int res2 = 0 ;
52474 wxGBSpan temp3 ;
52475
52476 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52478 if (!SWIG_IsOK(res1)) {
52479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52480 }
52481 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52482 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52483 if (!SWIG_IsOK(res2)) {
52484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52485 }
52486 arg2 = reinterpret_cast< wxWindow * >(argp2);
52487 {
52488 arg3 = &temp3;
52489 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52490 }
52491 {
52492 PyThreadState* __tstate = wxPyBeginAllowThreads();
52493 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52494 wxPyEndAllowThreads(__tstate);
52495 if (PyErr_Occurred()) SWIG_fail;
52496 }
52497 {
52498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52499 }
52500 return resultobj;
52501 fail:
52502 return NULL;
52503 }
52504
52505
52506 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52507 PyObject *resultobj = 0;
52508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52509 wxSizer *arg2 = (wxSizer *) 0 ;
52510 wxGBSpan *arg3 = 0 ;
52511 bool result;
52512 void *argp1 = 0 ;
52513 int res1 = 0 ;
52514 void *argp2 = 0 ;
52515 int res2 = 0 ;
52516 wxGBSpan temp3 ;
52517
52518 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52520 if (!SWIG_IsOK(res1)) {
52521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52522 }
52523 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52524 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52525 if (!SWIG_IsOK(res2)) {
52526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52527 }
52528 arg2 = reinterpret_cast< wxSizer * >(argp2);
52529 {
52530 arg3 = &temp3;
52531 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52532 }
52533 {
52534 PyThreadState* __tstate = wxPyBeginAllowThreads();
52535 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52536 wxPyEndAllowThreads(__tstate);
52537 if (PyErr_Occurred()) SWIG_fail;
52538 }
52539 {
52540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52541 }
52542 return resultobj;
52543 fail:
52544 return NULL;
52545 }
52546
52547
52548 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52549 PyObject *resultobj = 0;
52550 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52551 size_t arg2 ;
52552 wxGBSpan *arg3 = 0 ;
52553 bool result;
52554 void *argp1 = 0 ;
52555 int res1 = 0 ;
52556 size_t val2 ;
52557 int ecode2 = 0 ;
52558 wxGBSpan temp3 ;
52559
52560 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52562 if (!SWIG_IsOK(res1)) {
52563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52564 }
52565 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52566 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52567 if (!SWIG_IsOK(ecode2)) {
52568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52569 }
52570 arg2 = static_cast< size_t >(val2);
52571 {
52572 arg3 = &temp3;
52573 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52574 }
52575 {
52576 PyThreadState* __tstate = wxPyBeginAllowThreads();
52577 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52578 wxPyEndAllowThreads(__tstate);
52579 if (PyErr_Occurred()) SWIG_fail;
52580 }
52581 {
52582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52583 }
52584 return resultobj;
52585 fail:
52586 return NULL;
52587 }
52588
52589
52590 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52591 int argc;
52592 PyObject *argv[4];
52593
52594 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52595 --argc;
52596 if (argc == 3) {
52597 int _v = 0;
52598 {
52599 void *vptr = 0;
52600 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52601 _v = SWIG_CheckState(res);
52602 }
52603 if (!_v) goto check_1;
52604 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52605 }
52606 check_1:
52607
52608 if (argc == 3) {
52609 int _v = 0;
52610 {
52611 void *vptr = 0;
52612 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52613 _v = SWIG_CheckState(res);
52614 }
52615 if (!_v) goto check_2;
52616 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52617 }
52618 check_2:
52619
52620 if (argc == 3) {
52621 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52622 }
52623
52624 fail:
52625 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52631 PyObject *resultobj = 0;
52632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52633 wxWindow *arg2 = (wxWindow *) 0 ;
52634 wxGBSizerItem *result = 0 ;
52635 void *argp1 = 0 ;
52636 int res1 = 0 ;
52637 void *argp2 = 0 ;
52638 int res2 = 0 ;
52639
52640 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52642 if (!SWIG_IsOK(res1)) {
52643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52644 }
52645 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52646 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52647 if (!SWIG_IsOK(res2)) {
52648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52649 }
52650 arg2 = reinterpret_cast< wxWindow * >(argp2);
52651 {
52652 PyThreadState* __tstate = wxPyBeginAllowThreads();
52653 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52654 wxPyEndAllowThreads(__tstate);
52655 if (PyErr_Occurred()) SWIG_fail;
52656 }
52657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52658 return resultobj;
52659 fail:
52660 return NULL;
52661 }
52662
52663
52664 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52665 PyObject *resultobj = 0;
52666 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52667 wxSizer *arg2 = (wxSizer *) 0 ;
52668 wxGBSizerItem *result = 0 ;
52669 void *argp1 = 0 ;
52670 int res1 = 0 ;
52671 void *argp2 = 0 ;
52672 int res2 = 0 ;
52673
52674 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52676 if (!SWIG_IsOK(res1)) {
52677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52678 }
52679 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52680 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52681 if (!SWIG_IsOK(res2)) {
52682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52683 }
52684 arg2 = reinterpret_cast< wxSizer * >(argp2);
52685 {
52686 PyThreadState* __tstate = wxPyBeginAllowThreads();
52687 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52688 wxPyEndAllowThreads(__tstate);
52689 if (PyErr_Occurred()) SWIG_fail;
52690 }
52691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52692 return resultobj;
52693 fail:
52694 return NULL;
52695 }
52696
52697
52698 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52699 int argc;
52700 PyObject *argv[3];
52701
52702 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52703 --argc;
52704 if (argc == 2) {
52705 int _v = 0;
52706 {
52707 void *vptr = 0;
52708 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52709 _v = SWIG_CheckState(res);
52710 }
52711 if (!_v) goto check_1;
52712 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52713 }
52714 check_1:
52715
52716 if (argc == 2) {
52717 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52718 }
52719
52720 fail:
52721 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52722 return NULL;
52723 }
52724
52725
52726 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52727 PyObject *resultobj = 0;
52728 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52729 wxGBPosition *arg2 = 0 ;
52730 wxGBSizerItem *result = 0 ;
52731 void *argp1 = 0 ;
52732 int res1 = 0 ;
52733 wxGBPosition temp2 ;
52734 PyObject * obj0 = 0 ;
52735 PyObject * obj1 = 0 ;
52736 char * kwnames[] = {
52737 (char *) "self",(char *) "pos", NULL
52738 };
52739
52740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52742 if (!SWIG_IsOK(res1)) {
52743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52744 }
52745 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52746 {
52747 arg2 = &temp2;
52748 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52749 }
52750 {
52751 PyThreadState* __tstate = wxPyBeginAllowThreads();
52752 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52753 wxPyEndAllowThreads(__tstate);
52754 if (PyErr_Occurred()) SWIG_fail;
52755 }
52756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52757 return resultobj;
52758 fail:
52759 return NULL;
52760 }
52761
52762
52763 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52764 PyObject *resultobj = 0;
52765 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52766 wxPoint *arg2 = 0 ;
52767 wxGBSizerItem *result = 0 ;
52768 void *argp1 = 0 ;
52769 int res1 = 0 ;
52770 wxPoint temp2 ;
52771 PyObject * obj0 = 0 ;
52772 PyObject * obj1 = 0 ;
52773 char * kwnames[] = {
52774 (char *) "self",(char *) "pt", NULL
52775 };
52776
52777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52779 if (!SWIG_IsOK(res1)) {
52780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52781 }
52782 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52783 {
52784 arg2 = &temp2;
52785 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52786 }
52787 {
52788 PyThreadState* __tstate = wxPyBeginAllowThreads();
52789 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52790 wxPyEndAllowThreads(__tstate);
52791 if (PyErr_Occurred()) SWIG_fail;
52792 }
52793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52794 return resultobj;
52795 fail:
52796 return NULL;
52797 }
52798
52799
52800 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52801 PyObject *resultobj = 0;
52802 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52803 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52804 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52805 bool result;
52806 void *argp1 = 0 ;
52807 int res1 = 0 ;
52808 void *argp2 = 0 ;
52809 int res2 = 0 ;
52810 void *argp3 = 0 ;
52811 int res3 = 0 ;
52812 PyObject * obj0 = 0 ;
52813 PyObject * obj1 = 0 ;
52814 PyObject * obj2 = 0 ;
52815 char * kwnames[] = {
52816 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52817 };
52818
52819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52821 if (!SWIG_IsOK(res1)) {
52822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52823 }
52824 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52826 if (!SWIG_IsOK(res2)) {
52827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52828 }
52829 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52830 if (obj2) {
52831 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52832 if (!SWIG_IsOK(res3)) {
52833 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52834 }
52835 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52836 }
52837 {
52838 PyThreadState* __tstate = wxPyBeginAllowThreads();
52839 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52840 wxPyEndAllowThreads(__tstate);
52841 if (PyErr_Occurred()) SWIG_fail;
52842 }
52843 {
52844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52845 }
52846 return resultobj;
52847 fail:
52848 return NULL;
52849 }
52850
52851
52852 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52853 PyObject *resultobj = 0;
52854 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52855 wxGBPosition *arg2 = 0 ;
52856 wxGBSpan *arg3 = 0 ;
52857 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52858 bool result;
52859 void *argp1 = 0 ;
52860 int res1 = 0 ;
52861 wxGBPosition temp2 ;
52862 wxGBSpan temp3 ;
52863 void *argp4 = 0 ;
52864 int res4 = 0 ;
52865 PyObject * obj0 = 0 ;
52866 PyObject * obj1 = 0 ;
52867 PyObject * obj2 = 0 ;
52868 PyObject * obj3 = 0 ;
52869 char * kwnames[] = {
52870 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52871 };
52872
52873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52875 if (!SWIG_IsOK(res1)) {
52876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52877 }
52878 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52879 {
52880 arg2 = &temp2;
52881 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52882 }
52883 {
52884 arg3 = &temp3;
52885 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52886 }
52887 if (obj3) {
52888 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52889 if (!SWIG_IsOK(res4)) {
52890 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52891 }
52892 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52893 }
52894 {
52895 PyThreadState* __tstate = wxPyBeginAllowThreads();
52896 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52897 wxPyEndAllowThreads(__tstate);
52898 if (PyErr_Occurred()) SWIG_fail;
52899 }
52900 {
52901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52902 }
52903 return resultobj;
52904 fail:
52905 return NULL;
52906 }
52907
52908
52909 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52910 PyObject *obj;
52911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52912 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52913 return SWIG_Py_Void();
52914 }
52915
52916 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52917 return SWIG_Python_InitShadowInstance(args);
52918 }
52919
52920 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52921 PyObject *resultobj = 0;
52922 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52923 wxRelationship arg2 ;
52924 wxWindow *arg3 = (wxWindow *) 0 ;
52925 wxEdge arg4 ;
52926 int arg5 = (int) 0 ;
52927 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52928 void *argp1 = 0 ;
52929 int res1 = 0 ;
52930 int val2 ;
52931 int ecode2 = 0 ;
52932 void *argp3 = 0 ;
52933 int res3 = 0 ;
52934 int val4 ;
52935 int ecode4 = 0 ;
52936 int val5 ;
52937 int ecode5 = 0 ;
52938 int val6 ;
52939 int ecode6 = 0 ;
52940 PyObject * obj0 = 0 ;
52941 PyObject * obj1 = 0 ;
52942 PyObject * obj2 = 0 ;
52943 PyObject * obj3 = 0 ;
52944 PyObject * obj4 = 0 ;
52945 PyObject * obj5 = 0 ;
52946 char * kwnames[] = {
52947 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52948 };
52949
52950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52952 if (!SWIG_IsOK(res1)) {
52953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52954 }
52955 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52956 ecode2 = SWIG_AsVal_int(obj1, &val2);
52957 if (!SWIG_IsOK(ecode2)) {
52958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52959 }
52960 arg2 = static_cast< wxRelationship >(val2);
52961 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52962 if (!SWIG_IsOK(res3)) {
52963 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52964 }
52965 arg3 = reinterpret_cast< wxWindow * >(argp3);
52966 ecode4 = SWIG_AsVal_int(obj3, &val4);
52967 if (!SWIG_IsOK(ecode4)) {
52968 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52969 }
52970 arg4 = static_cast< wxEdge >(val4);
52971 if (obj4) {
52972 ecode5 = SWIG_AsVal_int(obj4, &val5);
52973 if (!SWIG_IsOK(ecode5)) {
52974 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52975 }
52976 arg5 = static_cast< int >(val5);
52977 }
52978 if (obj5) {
52979 ecode6 = SWIG_AsVal_int(obj5, &val6);
52980 if (!SWIG_IsOK(ecode6)) {
52981 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52982 }
52983 arg6 = static_cast< int >(val6);
52984 }
52985 {
52986 PyThreadState* __tstate = wxPyBeginAllowThreads();
52987 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52988 wxPyEndAllowThreads(__tstate);
52989 if (PyErr_Occurred()) SWIG_fail;
52990 }
52991 resultobj = SWIG_Py_Void();
52992 return resultobj;
52993 fail:
52994 return NULL;
52995 }
52996
52997
52998 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52999 PyObject *resultobj = 0;
53000 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53001 wxWindow *arg2 = (wxWindow *) 0 ;
53002 int arg3 = (int) 0 ;
53003 void *argp1 = 0 ;
53004 int res1 = 0 ;
53005 void *argp2 = 0 ;
53006 int res2 = 0 ;
53007 int val3 ;
53008 int ecode3 = 0 ;
53009 PyObject * obj0 = 0 ;
53010 PyObject * obj1 = 0 ;
53011 PyObject * obj2 = 0 ;
53012 char * kwnames[] = {
53013 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53014 };
53015
53016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53018 if (!SWIG_IsOK(res1)) {
53019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53020 }
53021 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53023 if (!SWIG_IsOK(res2)) {
53024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53025 }
53026 arg2 = reinterpret_cast< wxWindow * >(argp2);
53027 if (obj2) {
53028 ecode3 = SWIG_AsVal_int(obj2, &val3);
53029 if (!SWIG_IsOK(ecode3)) {
53030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
53031 }
53032 arg3 = static_cast< int >(val3);
53033 }
53034 {
53035 PyThreadState* __tstate = wxPyBeginAllowThreads();
53036 (arg1)->LeftOf(arg2,arg3);
53037 wxPyEndAllowThreads(__tstate);
53038 if (PyErr_Occurred()) SWIG_fail;
53039 }
53040 resultobj = SWIG_Py_Void();
53041 return resultobj;
53042 fail:
53043 return NULL;
53044 }
53045
53046
53047 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53048 PyObject *resultobj = 0;
53049 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53050 wxWindow *arg2 = (wxWindow *) 0 ;
53051 int arg3 = (int) 0 ;
53052 void *argp1 = 0 ;
53053 int res1 = 0 ;
53054 void *argp2 = 0 ;
53055 int res2 = 0 ;
53056 int val3 ;
53057 int ecode3 = 0 ;
53058 PyObject * obj0 = 0 ;
53059 PyObject * obj1 = 0 ;
53060 PyObject * obj2 = 0 ;
53061 char * kwnames[] = {
53062 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53063 };
53064
53065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53067 if (!SWIG_IsOK(res1)) {
53068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53069 }
53070 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53071 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53072 if (!SWIG_IsOK(res2)) {
53073 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53074 }
53075 arg2 = reinterpret_cast< wxWindow * >(argp2);
53076 if (obj2) {
53077 ecode3 = SWIG_AsVal_int(obj2, &val3);
53078 if (!SWIG_IsOK(ecode3)) {
53079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
53080 }
53081 arg3 = static_cast< int >(val3);
53082 }
53083 {
53084 PyThreadState* __tstate = wxPyBeginAllowThreads();
53085 (arg1)->RightOf(arg2,arg3);
53086 wxPyEndAllowThreads(__tstate);
53087 if (PyErr_Occurred()) SWIG_fail;
53088 }
53089 resultobj = SWIG_Py_Void();
53090 return resultobj;
53091 fail:
53092 return NULL;
53093 }
53094
53095
53096 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53097 PyObject *resultobj = 0;
53098 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53099 wxWindow *arg2 = (wxWindow *) 0 ;
53100 int arg3 = (int) 0 ;
53101 void *argp1 = 0 ;
53102 int res1 = 0 ;
53103 void *argp2 = 0 ;
53104 int res2 = 0 ;
53105 int val3 ;
53106 int ecode3 = 0 ;
53107 PyObject * obj0 = 0 ;
53108 PyObject * obj1 = 0 ;
53109 PyObject * obj2 = 0 ;
53110 char * kwnames[] = {
53111 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53112 };
53113
53114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53116 if (!SWIG_IsOK(res1)) {
53117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53118 }
53119 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53120 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53121 if (!SWIG_IsOK(res2)) {
53122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
53123 }
53124 arg2 = reinterpret_cast< wxWindow * >(argp2);
53125 if (obj2) {
53126 ecode3 = SWIG_AsVal_int(obj2, &val3);
53127 if (!SWIG_IsOK(ecode3)) {
53128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
53129 }
53130 arg3 = static_cast< int >(val3);
53131 }
53132 {
53133 PyThreadState* __tstate = wxPyBeginAllowThreads();
53134 (arg1)->Above(arg2,arg3);
53135 wxPyEndAllowThreads(__tstate);
53136 if (PyErr_Occurred()) SWIG_fail;
53137 }
53138 resultobj = SWIG_Py_Void();
53139 return resultobj;
53140 fail:
53141 return NULL;
53142 }
53143
53144
53145 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53146 PyObject *resultobj = 0;
53147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53148 wxWindow *arg2 = (wxWindow *) 0 ;
53149 int arg3 = (int) 0 ;
53150 void *argp1 = 0 ;
53151 int res1 = 0 ;
53152 void *argp2 = 0 ;
53153 int res2 = 0 ;
53154 int val3 ;
53155 int ecode3 = 0 ;
53156 PyObject * obj0 = 0 ;
53157 PyObject * obj1 = 0 ;
53158 PyObject * obj2 = 0 ;
53159 char * kwnames[] = {
53160 (char *) "self",(char *) "sibling",(char *) "marg", NULL
53161 };
53162
53163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53165 if (!SWIG_IsOK(res1)) {
53166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53167 }
53168 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53169 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53170 if (!SWIG_IsOK(res2)) {
53171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
53172 }
53173 arg2 = reinterpret_cast< wxWindow * >(argp2);
53174 if (obj2) {
53175 ecode3 = SWIG_AsVal_int(obj2, &val3);
53176 if (!SWIG_IsOK(ecode3)) {
53177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
53178 }
53179 arg3 = static_cast< int >(val3);
53180 }
53181 {
53182 PyThreadState* __tstate = wxPyBeginAllowThreads();
53183 (arg1)->Below(arg2,arg3);
53184 wxPyEndAllowThreads(__tstate);
53185 if (PyErr_Occurred()) SWIG_fail;
53186 }
53187 resultobj = SWIG_Py_Void();
53188 return resultobj;
53189 fail:
53190 return NULL;
53191 }
53192
53193
53194 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53195 PyObject *resultobj = 0;
53196 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53197 wxWindow *arg2 = (wxWindow *) 0 ;
53198 wxEdge arg3 ;
53199 int arg4 = (int) 0 ;
53200 void *argp1 = 0 ;
53201 int res1 = 0 ;
53202 void *argp2 = 0 ;
53203 int res2 = 0 ;
53204 int val3 ;
53205 int ecode3 = 0 ;
53206 int val4 ;
53207 int ecode4 = 0 ;
53208 PyObject * obj0 = 0 ;
53209 PyObject * obj1 = 0 ;
53210 PyObject * obj2 = 0 ;
53211 PyObject * obj3 = 0 ;
53212 char * kwnames[] = {
53213 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
53214 };
53215
53216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53218 if (!SWIG_IsOK(res1)) {
53219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53220 }
53221 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53223 if (!SWIG_IsOK(res2)) {
53224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
53225 }
53226 arg2 = reinterpret_cast< wxWindow * >(argp2);
53227 ecode3 = SWIG_AsVal_int(obj2, &val3);
53228 if (!SWIG_IsOK(ecode3)) {
53229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
53230 }
53231 arg3 = static_cast< wxEdge >(val3);
53232 if (obj3) {
53233 ecode4 = SWIG_AsVal_int(obj3, &val4);
53234 if (!SWIG_IsOK(ecode4)) {
53235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
53236 }
53237 arg4 = static_cast< int >(val4);
53238 }
53239 {
53240 PyThreadState* __tstate = wxPyBeginAllowThreads();
53241 (arg1)->SameAs(arg2,arg3,arg4);
53242 wxPyEndAllowThreads(__tstate);
53243 if (PyErr_Occurred()) SWIG_fail;
53244 }
53245 resultobj = SWIG_Py_Void();
53246 return resultobj;
53247 fail:
53248 return NULL;
53249 }
53250
53251
53252 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53253 PyObject *resultobj = 0;
53254 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53255 wxWindow *arg2 = (wxWindow *) 0 ;
53256 wxEdge arg3 ;
53257 int arg4 ;
53258 void *argp1 = 0 ;
53259 int res1 = 0 ;
53260 void *argp2 = 0 ;
53261 int res2 = 0 ;
53262 int val3 ;
53263 int ecode3 = 0 ;
53264 int val4 ;
53265 int ecode4 = 0 ;
53266 PyObject * obj0 = 0 ;
53267 PyObject * obj1 = 0 ;
53268 PyObject * obj2 = 0 ;
53269 PyObject * obj3 = 0 ;
53270 char * kwnames[] = {
53271 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
53272 };
53273
53274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53276 if (!SWIG_IsOK(res1)) {
53277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53278 }
53279 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53281 if (!SWIG_IsOK(res2)) {
53282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
53283 }
53284 arg2 = reinterpret_cast< wxWindow * >(argp2);
53285 ecode3 = SWIG_AsVal_int(obj2, &val3);
53286 if (!SWIG_IsOK(ecode3)) {
53287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
53288 }
53289 arg3 = static_cast< wxEdge >(val3);
53290 ecode4 = SWIG_AsVal_int(obj3, &val4);
53291 if (!SWIG_IsOK(ecode4)) {
53292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
53293 }
53294 arg4 = static_cast< int >(val4);
53295 {
53296 PyThreadState* __tstate = wxPyBeginAllowThreads();
53297 (arg1)->PercentOf(arg2,arg3,arg4);
53298 wxPyEndAllowThreads(__tstate);
53299 if (PyErr_Occurred()) SWIG_fail;
53300 }
53301 resultobj = SWIG_Py_Void();
53302 return resultobj;
53303 fail:
53304 return NULL;
53305 }
53306
53307
53308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53309 PyObject *resultobj = 0;
53310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53311 int arg2 ;
53312 void *argp1 = 0 ;
53313 int res1 = 0 ;
53314 int val2 ;
53315 int ecode2 = 0 ;
53316 PyObject * obj0 = 0 ;
53317 PyObject * obj1 = 0 ;
53318 char * kwnames[] = {
53319 (char *) "self",(char *) "val", NULL
53320 };
53321
53322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
53323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53324 if (!SWIG_IsOK(res1)) {
53325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53326 }
53327 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53328 ecode2 = SWIG_AsVal_int(obj1, &val2);
53329 if (!SWIG_IsOK(ecode2)) {
53330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
53331 }
53332 arg2 = static_cast< int >(val2);
53333 {
53334 PyThreadState* __tstate = wxPyBeginAllowThreads();
53335 (arg1)->Absolute(arg2);
53336 wxPyEndAllowThreads(__tstate);
53337 if (PyErr_Occurred()) SWIG_fail;
53338 }
53339 resultobj = SWIG_Py_Void();
53340 return resultobj;
53341 fail:
53342 return NULL;
53343 }
53344
53345
53346 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53347 PyObject *resultobj = 0;
53348 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53349 void *argp1 = 0 ;
53350 int res1 = 0 ;
53351 PyObject *swig_obj[1] ;
53352
53353 if (!args) SWIG_fail;
53354 swig_obj[0] = args;
53355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53356 if (!SWIG_IsOK(res1)) {
53357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53358 }
53359 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53360 {
53361 PyThreadState* __tstate = wxPyBeginAllowThreads();
53362 (arg1)->Unconstrained();
53363 wxPyEndAllowThreads(__tstate);
53364 if (PyErr_Occurred()) SWIG_fail;
53365 }
53366 resultobj = SWIG_Py_Void();
53367 return resultobj;
53368 fail:
53369 return NULL;
53370 }
53371
53372
53373 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53374 PyObject *resultobj = 0;
53375 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53376 void *argp1 = 0 ;
53377 int res1 = 0 ;
53378 PyObject *swig_obj[1] ;
53379
53380 if (!args) SWIG_fail;
53381 swig_obj[0] = args;
53382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53383 if (!SWIG_IsOK(res1)) {
53384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53385 }
53386 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53387 {
53388 PyThreadState* __tstate = wxPyBeginAllowThreads();
53389 (arg1)->AsIs();
53390 wxPyEndAllowThreads(__tstate);
53391 if (PyErr_Occurred()) SWIG_fail;
53392 }
53393 resultobj = SWIG_Py_Void();
53394 return resultobj;
53395 fail:
53396 return NULL;
53397 }
53398
53399
53400 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53401 PyObject *resultobj = 0;
53402 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53403 wxWindow *result = 0 ;
53404 void *argp1 = 0 ;
53405 int res1 = 0 ;
53406 PyObject *swig_obj[1] ;
53407
53408 if (!args) SWIG_fail;
53409 swig_obj[0] = args;
53410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53411 if (!SWIG_IsOK(res1)) {
53412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53413 }
53414 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53415 {
53416 PyThreadState* __tstate = wxPyBeginAllowThreads();
53417 result = (wxWindow *)(arg1)->GetOtherWindow();
53418 wxPyEndAllowThreads(__tstate);
53419 if (PyErr_Occurred()) SWIG_fail;
53420 }
53421 {
53422 resultobj = wxPyMake_wxObject(result, 0);
53423 }
53424 return resultobj;
53425 fail:
53426 return NULL;
53427 }
53428
53429
53430 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53431 PyObject *resultobj = 0;
53432 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53433 wxEdge result;
53434 void *argp1 = 0 ;
53435 int res1 = 0 ;
53436 PyObject *swig_obj[1] ;
53437
53438 if (!args) SWIG_fail;
53439 swig_obj[0] = args;
53440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53441 if (!SWIG_IsOK(res1)) {
53442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53443 }
53444 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53445 {
53446 PyThreadState* __tstate = wxPyBeginAllowThreads();
53447 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53448 wxPyEndAllowThreads(__tstate);
53449 if (PyErr_Occurred()) SWIG_fail;
53450 }
53451 resultobj = SWIG_From_int(static_cast< int >(result));
53452 return resultobj;
53453 fail:
53454 return NULL;
53455 }
53456
53457
53458 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53459 PyObject *resultobj = 0;
53460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53461 wxEdge arg2 ;
53462 void *argp1 = 0 ;
53463 int res1 = 0 ;
53464 int val2 ;
53465 int ecode2 = 0 ;
53466 PyObject * obj0 = 0 ;
53467 PyObject * obj1 = 0 ;
53468 char * kwnames[] = {
53469 (char *) "self",(char *) "which", NULL
53470 };
53471
53472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53474 if (!SWIG_IsOK(res1)) {
53475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53476 }
53477 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53478 ecode2 = SWIG_AsVal_int(obj1, &val2);
53479 if (!SWIG_IsOK(ecode2)) {
53480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53481 }
53482 arg2 = static_cast< wxEdge >(val2);
53483 {
53484 PyThreadState* __tstate = wxPyBeginAllowThreads();
53485 (arg1)->SetEdge(arg2);
53486 wxPyEndAllowThreads(__tstate);
53487 if (PyErr_Occurred()) SWIG_fail;
53488 }
53489 resultobj = SWIG_Py_Void();
53490 return resultobj;
53491 fail:
53492 return NULL;
53493 }
53494
53495
53496 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53497 PyObject *resultobj = 0;
53498 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53499 int arg2 ;
53500 void *argp1 = 0 ;
53501 int res1 = 0 ;
53502 int val2 ;
53503 int ecode2 = 0 ;
53504 PyObject * obj0 = 0 ;
53505 PyObject * obj1 = 0 ;
53506 char * kwnames[] = {
53507 (char *) "self",(char *) "v", NULL
53508 };
53509
53510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53512 if (!SWIG_IsOK(res1)) {
53513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53514 }
53515 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53516 ecode2 = SWIG_AsVal_int(obj1, &val2);
53517 if (!SWIG_IsOK(ecode2)) {
53518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53519 }
53520 arg2 = static_cast< int >(val2);
53521 {
53522 PyThreadState* __tstate = wxPyBeginAllowThreads();
53523 (arg1)->SetValue(arg2);
53524 wxPyEndAllowThreads(__tstate);
53525 if (PyErr_Occurred()) SWIG_fail;
53526 }
53527 resultobj = SWIG_Py_Void();
53528 return resultobj;
53529 fail:
53530 return NULL;
53531 }
53532
53533
53534 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53535 PyObject *resultobj = 0;
53536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53537 int result;
53538 void *argp1 = 0 ;
53539 int res1 = 0 ;
53540 PyObject *swig_obj[1] ;
53541
53542 if (!args) SWIG_fail;
53543 swig_obj[0] = args;
53544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53545 if (!SWIG_IsOK(res1)) {
53546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53547 }
53548 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53549 {
53550 PyThreadState* __tstate = wxPyBeginAllowThreads();
53551 result = (int)(arg1)->GetMargin();
53552 wxPyEndAllowThreads(__tstate);
53553 if (PyErr_Occurred()) SWIG_fail;
53554 }
53555 resultobj = SWIG_From_int(static_cast< int >(result));
53556 return resultobj;
53557 fail:
53558 return NULL;
53559 }
53560
53561
53562 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53563 PyObject *resultobj = 0;
53564 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53565 int arg2 ;
53566 void *argp1 = 0 ;
53567 int res1 = 0 ;
53568 int val2 ;
53569 int ecode2 = 0 ;
53570 PyObject * obj0 = 0 ;
53571 PyObject * obj1 = 0 ;
53572 char * kwnames[] = {
53573 (char *) "self",(char *) "m", NULL
53574 };
53575
53576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53578 if (!SWIG_IsOK(res1)) {
53579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53580 }
53581 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53582 ecode2 = SWIG_AsVal_int(obj1, &val2);
53583 if (!SWIG_IsOK(ecode2)) {
53584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53585 }
53586 arg2 = static_cast< int >(val2);
53587 {
53588 PyThreadState* __tstate = wxPyBeginAllowThreads();
53589 (arg1)->SetMargin(arg2);
53590 wxPyEndAllowThreads(__tstate);
53591 if (PyErr_Occurred()) SWIG_fail;
53592 }
53593 resultobj = SWIG_Py_Void();
53594 return resultobj;
53595 fail:
53596 return NULL;
53597 }
53598
53599
53600 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53601 PyObject *resultobj = 0;
53602 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53603 int result;
53604 void *argp1 = 0 ;
53605 int res1 = 0 ;
53606 PyObject *swig_obj[1] ;
53607
53608 if (!args) SWIG_fail;
53609 swig_obj[0] = args;
53610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53611 if (!SWIG_IsOK(res1)) {
53612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53613 }
53614 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53615 {
53616 PyThreadState* __tstate = wxPyBeginAllowThreads();
53617 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53618 wxPyEndAllowThreads(__tstate);
53619 if (PyErr_Occurred()) SWIG_fail;
53620 }
53621 resultobj = SWIG_From_int(static_cast< int >(result));
53622 return resultobj;
53623 fail:
53624 return NULL;
53625 }
53626
53627
53628 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53629 PyObject *resultobj = 0;
53630 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53631 int result;
53632 void *argp1 = 0 ;
53633 int res1 = 0 ;
53634 PyObject *swig_obj[1] ;
53635
53636 if (!args) SWIG_fail;
53637 swig_obj[0] = args;
53638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53639 if (!SWIG_IsOK(res1)) {
53640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53641 }
53642 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53643 {
53644 PyThreadState* __tstate = wxPyBeginAllowThreads();
53645 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53646 wxPyEndAllowThreads(__tstate);
53647 if (PyErr_Occurred()) SWIG_fail;
53648 }
53649 resultobj = SWIG_From_int(static_cast< int >(result));
53650 return resultobj;
53651 fail:
53652 return NULL;
53653 }
53654
53655
53656 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53657 PyObject *resultobj = 0;
53658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53659 int result;
53660 void *argp1 = 0 ;
53661 int res1 = 0 ;
53662 PyObject *swig_obj[1] ;
53663
53664 if (!args) SWIG_fail;
53665 swig_obj[0] = args;
53666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53667 if (!SWIG_IsOK(res1)) {
53668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53669 }
53670 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53671 {
53672 PyThreadState* __tstate = wxPyBeginAllowThreads();
53673 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53674 wxPyEndAllowThreads(__tstate);
53675 if (PyErr_Occurred()) SWIG_fail;
53676 }
53677 resultobj = SWIG_From_int(static_cast< int >(result));
53678 return resultobj;
53679 fail:
53680 return NULL;
53681 }
53682
53683
53684 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53685 PyObject *resultobj = 0;
53686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53687 bool result;
53688 void *argp1 = 0 ;
53689 int res1 = 0 ;
53690 PyObject *swig_obj[1] ;
53691
53692 if (!args) SWIG_fail;
53693 swig_obj[0] = args;
53694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53695 if (!SWIG_IsOK(res1)) {
53696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53697 }
53698 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53699 {
53700 PyThreadState* __tstate = wxPyBeginAllowThreads();
53701 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53702 wxPyEndAllowThreads(__tstate);
53703 if (PyErr_Occurred()) SWIG_fail;
53704 }
53705 {
53706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53707 }
53708 return resultobj;
53709 fail:
53710 return NULL;
53711 }
53712
53713
53714 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53715 PyObject *resultobj = 0;
53716 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53717 bool arg2 ;
53718 void *argp1 = 0 ;
53719 int res1 = 0 ;
53720 bool val2 ;
53721 int ecode2 = 0 ;
53722 PyObject * obj0 = 0 ;
53723 PyObject * obj1 = 0 ;
53724 char * kwnames[] = {
53725 (char *) "self",(char *) "d", NULL
53726 };
53727
53728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53730 if (!SWIG_IsOK(res1)) {
53731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53732 }
53733 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53734 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53735 if (!SWIG_IsOK(ecode2)) {
53736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53737 }
53738 arg2 = static_cast< bool >(val2);
53739 {
53740 PyThreadState* __tstate = wxPyBeginAllowThreads();
53741 (arg1)->SetDone(arg2);
53742 wxPyEndAllowThreads(__tstate);
53743 if (PyErr_Occurred()) SWIG_fail;
53744 }
53745 resultobj = SWIG_Py_Void();
53746 return resultobj;
53747 fail:
53748 return NULL;
53749 }
53750
53751
53752 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53753 PyObject *resultobj = 0;
53754 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53755 wxRelationship result;
53756 void *argp1 = 0 ;
53757 int res1 = 0 ;
53758 PyObject *swig_obj[1] ;
53759
53760 if (!args) SWIG_fail;
53761 swig_obj[0] = args;
53762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53763 if (!SWIG_IsOK(res1)) {
53764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53765 }
53766 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53767 {
53768 PyThreadState* __tstate = wxPyBeginAllowThreads();
53769 result = (wxRelationship)(arg1)->GetRelationship();
53770 wxPyEndAllowThreads(__tstate);
53771 if (PyErr_Occurred()) SWIG_fail;
53772 }
53773 resultobj = SWIG_From_int(static_cast< int >(result));
53774 return resultobj;
53775 fail:
53776 return NULL;
53777 }
53778
53779
53780 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53781 PyObject *resultobj = 0;
53782 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53783 wxRelationship arg2 ;
53784 void *argp1 = 0 ;
53785 int res1 = 0 ;
53786 int val2 ;
53787 int ecode2 = 0 ;
53788 PyObject * obj0 = 0 ;
53789 PyObject * obj1 = 0 ;
53790 char * kwnames[] = {
53791 (char *) "self",(char *) "r", NULL
53792 };
53793
53794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53796 if (!SWIG_IsOK(res1)) {
53797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53798 }
53799 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53800 ecode2 = SWIG_AsVal_int(obj1, &val2);
53801 if (!SWIG_IsOK(ecode2)) {
53802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53803 }
53804 arg2 = static_cast< wxRelationship >(val2);
53805 {
53806 PyThreadState* __tstate = wxPyBeginAllowThreads();
53807 (arg1)->SetRelationship(arg2);
53808 wxPyEndAllowThreads(__tstate);
53809 if (PyErr_Occurred()) SWIG_fail;
53810 }
53811 resultobj = SWIG_Py_Void();
53812 return resultobj;
53813 fail:
53814 return NULL;
53815 }
53816
53817
53818 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53819 PyObject *resultobj = 0;
53820 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53821 wxWindow *arg2 = (wxWindow *) 0 ;
53822 bool result;
53823 void *argp1 = 0 ;
53824 int res1 = 0 ;
53825 void *argp2 = 0 ;
53826 int res2 = 0 ;
53827 PyObject * obj0 = 0 ;
53828 PyObject * obj1 = 0 ;
53829 char * kwnames[] = {
53830 (char *) "self",(char *) "otherW", NULL
53831 };
53832
53833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53835 if (!SWIG_IsOK(res1)) {
53836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53837 }
53838 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53840 if (!SWIG_IsOK(res2)) {
53841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53842 }
53843 arg2 = reinterpret_cast< wxWindow * >(argp2);
53844 {
53845 PyThreadState* __tstate = wxPyBeginAllowThreads();
53846 result = (bool)(arg1)->ResetIfWin(arg2);
53847 wxPyEndAllowThreads(__tstate);
53848 if (PyErr_Occurred()) SWIG_fail;
53849 }
53850 {
53851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53852 }
53853 return resultobj;
53854 fail:
53855 return NULL;
53856 }
53857
53858
53859 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53860 PyObject *resultobj = 0;
53861 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53862 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53863 wxWindow *arg3 = (wxWindow *) 0 ;
53864 bool result;
53865 void *argp1 = 0 ;
53866 int res1 = 0 ;
53867 void *argp2 = 0 ;
53868 int res2 = 0 ;
53869 void *argp3 = 0 ;
53870 int res3 = 0 ;
53871 PyObject * obj0 = 0 ;
53872 PyObject * obj1 = 0 ;
53873 PyObject * obj2 = 0 ;
53874 char * kwnames[] = {
53875 (char *) "self",(char *) "constraints",(char *) "win", NULL
53876 };
53877
53878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53880 if (!SWIG_IsOK(res1)) {
53881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53882 }
53883 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53884 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53885 if (!SWIG_IsOK(res2)) {
53886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53887 }
53888 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53889 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53890 if (!SWIG_IsOK(res3)) {
53891 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53892 }
53893 arg3 = reinterpret_cast< wxWindow * >(argp3);
53894 {
53895 PyThreadState* __tstate = wxPyBeginAllowThreads();
53896 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53897 wxPyEndAllowThreads(__tstate);
53898 if (PyErr_Occurred()) SWIG_fail;
53899 }
53900 {
53901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53902 }
53903 return resultobj;
53904 fail:
53905 return NULL;
53906 }
53907
53908
53909 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53910 PyObject *resultobj = 0;
53911 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53912 wxEdge arg2 ;
53913 wxWindow *arg3 = (wxWindow *) 0 ;
53914 wxWindow *arg4 = (wxWindow *) 0 ;
53915 int result;
53916 void *argp1 = 0 ;
53917 int res1 = 0 ;
53918 int val2 ;
53919 int ecode2 = 0 ;
53920 void *argp3 = 0 ;
53921 int res3 = 0 ;
53922 void *argp4 = 0 ;
53923 int res4 = 0 ;
53924 PyObject * obj0 = 0 ;
53925 PyObject * obj1 = 0 ;
53926 PyObject * obj2 = 0 ;
53927 PyObject * obj3 = 0 ;
53928 char * kwnames[] = {
53929 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53930 };
53931
53932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53934 if (!SWIG_IsOK(res1)) {
53935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53936 }
53937 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53938 ecode2 = SWIG_AsVal_int(obj1, &val2);
53939 if (!SWIG_IsOK(ecode2)) {
53940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53941 }
53942 arg2 = static_cast< wxEdge >(val2);
53943 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53944 if (!SWIG_IsOK(res3)) {
53945 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53946 }
53947 arg3 = reinterpret_cast< wxWindow * >(argp3);
53948 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53949 if (!SWIG_IsOK(res4)) {
53950 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53951 }
53952 arg4 = reinterpret_cast< wxWindow * >(argp4);
53953 {
53954 PyThreadState* __tstate = wxPyBeginAllowThreads();
53955 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53956 wxPyEndAllowThreads(__tstate);
53957 if (PyErr_Occurred()) SWIG_fail;
53958 }
53959 resultobj = SWIG_From_int(static_cast< int >(result));
53960 return resultobj;
53961 fail:
53962 return NULL;
53963 }
53964
53965
53966 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53967 PyObject *obj;
53968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53969 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53970 return SWIG_Py_Void();
53971 }
53972
53973 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53974 PyObject *resultobj = 0;
53975 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53976 wxIndividualLayoutConstraint *result = 0 ;
53977 void *argp1 = 0 ;
53978 int res1 = 0 ;
53979 PyObject *swig_obj[1] ;
53980
53981 if (!args) SWIG_fail;
53982 swig_obj[0] = args;
53983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53984 if (!SWIG_IsOK(res1)) {
53985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53986 }
53987 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53988 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53990 return resultobj;
53991 fail:
53992 return NULL;
53993 }
53994
53995
53996 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53997 PyObject *resultobj = 0;
53998 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53999 wxIndividualLayoutConstraint *result = 0 ;
54000 void *argp1 = 0 ;
54001 int res1 = 0 ;
54002 PyObject *swig_obj[1] ;
54003
54004 if (!args) SWIG_fail;
54005 swig_obj[0] = args;
54006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54007 if (!SWIG_IsOK(res1)) {
54008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54009 }
54010 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54011 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
54012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54013 return resultobj;
54014 fail:
54015 return NULL;
54016 }
54017
54018
54019 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54020 PyObject *resultobj = 0;
54021 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54022 wxIndividualLayoutConstraint *result = 0 ;
54023 void *argp1 = 0 ;
54024 int res1 = 0 ;
54025 PyObject *swig_obj[1] ;
54026
54027 if (!args) SWIG_fail;
54028 swig_obj[0] = args;
54029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54030 if (!SWIG_IsOK(res1)) {
54031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54032 }
54033 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54034 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
54035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54036 return resultobj;
54037 fail:
54038 return NULL;
54039 }
54040
54041
54042 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54043 PyObject *resultobj = 0;
54044 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54045 wxIndividualLayoutConstraint *result = 0 ;
54046 void *argp1 = 0 ;
54047 int res1 = 0 ;
54048 PyObject *swig_obj[1] ;
54049
54050 if (!args) SWIG_fail;
54051 swig_obj[0] = args;
54052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54053 if (!SWIG_IsOK(res1)) {
54054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54055 }
54056 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54057 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
54058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54059 return resultobj;
54060 fail:
54061 return NULL;
54062 }
54063
54064
54065 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54066 PyObject *resultobj = 0;
54067 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54068 wxIndividualLayoutConstraint *result = 0 ;
54069 void *argp1 = 0 ;
54070 int res1 = 0 ;
54071 PyObject *swig_obj[1] ;
54072
54073 if (!args) SWIG_fail;
54074 swig_obj[0] = args;
54075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54076 if (!SWIG_IsOK(res1)) {
54077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54078 }
54079 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54080 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
54081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54082 return resultobj;
54083 fail:
54084 return NULL;
54085 }
54086
54087
54088 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54089 PyObject *resultobj = 0;
54090 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54091 wxIndividualLayoutConstraint *result = 0 ;
54092 void *argp1 = 0 ;
54093 int res1 = 0 ;
54094 PyObject *swig_obj[1] ;
54095
54096 if (!args) SWIG_fail;
54097 swig_obj[0] = args;
54098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54099 if (!SWIG_IsOK(res1)) {
54100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54101 }
54102 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54103 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
54104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54105 return resultobj;
54106 fail:
54107 return NULL;
54108 }
54109
54110
54111 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54112 PyObject *resultobj = 0;
54113 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54114 wxIndividualLayoutConstraint *result = 0 ;
54115 void *argp1 = 0 ;
54116 int res1 = 0 ;
54117 PyObject *swig_obj[1] ;
54118
54119 if (!args) SWIG_fail;
54120 swig_obj[0] = args;
54121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54122 if (!SWIG_IsOK(res1)) {
54123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54124 }
54125 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54126 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
54127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54128 return resultobj;
54129 fail:
54130 return NULL;
54131 }
54132
54133
54134 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54135 PyObject *resultobj = 0;
54136 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54137 wxIndividualLayoutConstraint *result = 0 ;
54138 void *argp1 = 0 ;
54139 int res1 = 0 ;
54140 PyObject *swig_obj[1] ;
54141
54142 if (!args) SWIG_fail;
54143 swig_obj[0] = args;
54144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54145 if (!SWIG_IsOK(res1)) {
54146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54147 }
54148 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54149 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
54150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
54151 return resultobj;
54152 fail:
54153 return NULL;
54154 }
54155
54156
54157 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54158 PyObject *resultobj = 0;
54159 wxLayoutConstraints *result = 0 ;
54160
54161 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 result = (wxLayoutConstraints *)new wxLayoutConstraints();
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
54169 return resultobj;
54170 fail:
54171 return NULL;
54172 }
54173
54174
54175 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54176 PyObject *resultobj = 0;
54177 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54178 void *argp1 = 0 ;
54179 int res1 = 0 ;
54180 PyObject *swig_obj[1] ;
54181
54182 if (!args) SWIG_fail;
54183 swig_obj[0] = args;
54184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
54185 if (!SWIG_IsOK(res1)) {
54186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54187 }
54188 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54189 {
54190 PyThreadState* __tstate = wxPyBeginAllowThreads();
54191 delete arg1;
54192
54193 wxPyEndAllowThreads(__tstate);
54194 if (PyErr_Occurred()) SWIG_fail;
54195 }
54196 resultobj = SWIG_Py_Void();
54197 return resultobj;
54198 fail:
54199 return NULL;
54200 }
54201
54202
54203 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54204 PyObject *resultobj = 0;
54205 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54206 wxWindow *arg2 = (wxWindow *) 0 ;
54207 int *arg3 = (int *) 0 ;
54208 bool result;
54209 void *argp1 = 0 ;
54210 int res1 = 0 ;
54211 void *argp2 = 0 ;
54212 int res2 = 0 ;
54213 int temp3 ;
54214 int res3 = SWIG_TMPOBJ ;
54215 PyObject * obj0 = 0 ;
54216 PyObject * obj1 = 0 ;
54217 char * kwnames[] = {
54218 (char *) "self",(char *) "win", NULL
54219 };
54220
54221 arg3 = &temp3;
54222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
54223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54224 if (!SWIG_IsOK(res1)) {
54225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
54226 }
54227 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54229 if (!SWIG_IsOK(res2)) {
54230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
54231 }
54232 arg2 = reinterpret_cast< wxWindow * >(argp2);
54233 {
54234 PyThreadState* __tstate = wxPyBeginAllowThreads();
54235 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
54236 wxPyEndAllowThreads(__tstate);
54237 if (PyErr_Occurred()) SWIG_fail;
54238 }
54239 {
54240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54241 }
54242 if (SWIG_IsTmpObj(res3)) {
54243 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
54244 } else {
54245 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
54246 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
54247 }
54248 return resultobj;
54249 fail:
54250 return NULL;
54251 }
54252
54253
54254 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54255 PyObject *resultobj = 0;
54256 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
54257 bool result;
54258 void *argp1 = 0 ;
54259 int res1 = 0 ;
54260 PyObject *swig_obj[1] ;
54261
54262 if (!args) SWIG_fail;
54263 swig_obj[0] = args;
54264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
54265 if (!SWIG_IsOK(res1)) {
54266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
54267 }
54268 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
54269 {
54270 PyThreadState* __tstate = wxPyBeginAllowThreads();
54271 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
54272 wxPyEndAllowThreads(__tstate);
54273 if (PyErr_Occurred()) SWIG_fail;
54274 }
54275 {
54276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54277 }
54278 return resultobj;
54279 fail:
54280 return NULL;
54281 }
54282
54283
54284 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54285 PyObject *obj;
54286 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54287 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
54288 return SWIG_Py_Void();
54289 }
54290
54291 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54292 return SWIG_Python_InitShadowInstance(args);
54293 }
54294
54295 static PyMethodDef SwigMethods[] = {
54296 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
54297 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
54298 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
54299 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
54300 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
54301 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
54302 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
54303 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
54304 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54305 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
54306 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54315 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
54319 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
54320 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
54321 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
54322 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
54323 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
54324 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
54325 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
54326 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
54327 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
54328 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
54329 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
54331 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
54337 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
54338 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
54339 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
54340 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
54341 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
54342 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
54343 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
54345 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54351 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
54353 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
54354 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
54355 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
54360 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
54361 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
54363 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
54365 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
54367 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
54369 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
54371 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
54373 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
54374 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54375 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
54376 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
54378 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
54380 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
54382 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
54383 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
54384 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
54385 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
54387 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
54390 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
54405 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
54406 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
54407 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
54408 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
54409 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
54410 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
54411 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
54412 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
54414 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
54415 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
54416 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
54418 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
54421 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
54422 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
54423 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
54424 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
54425 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54430 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
54432 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54437 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
54439 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
54440 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
54441 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
54442 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
54444 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
54445 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54448 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54449 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54450 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54451 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54456 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54457 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54458 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54459 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54460 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54461 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54464 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54465 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54466 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54468 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54469 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54471 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54472 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54473 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54474 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54475 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54476 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54477 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54478 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54479 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54480 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54481 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54482 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54483 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54487 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54493 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54494 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54495 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54496 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54497 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54498 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54501 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54502 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54504 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54507 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54508 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54509 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54511 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54512 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54513 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54514 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54517 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54518 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54519 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54520 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54524 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54529 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54530 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54531 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54532 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54533 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54534 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54535 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54542 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54543 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54545 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54546 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54547 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54553 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54554 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54555 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54556 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54557 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54558 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54559 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54560 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54561 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54562 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54563 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54564 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54565 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54566 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54567 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54568 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54569 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54570 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54571 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54572 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54573 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54574 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54579 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54583 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
54585 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54600 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54601 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54614 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
54616 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54617 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54618 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54619 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54622 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54624 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54626 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54628 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54630 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54631 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54633 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54634 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54635 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54636 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54638 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54639 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54640 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54655 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54656 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54661 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54662 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54663 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54665 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54666 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54667 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54668 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54669 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54670 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54671 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54672 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54673 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54674 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54675 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54676 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54677 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54678 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54679 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54680 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54681 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54682 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54683 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54684 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54685 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54686 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54687 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54688 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54689 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54690 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54691 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54692 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54693 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54694 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54695 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54696 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54697 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54699 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54700 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54701 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54702 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54705 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54709 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
54711 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
54712 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54716 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54717 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54718 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54719 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54721 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54722 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54724 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54726 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54728 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54730 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54731 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54732 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54734 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54735 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54737 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54738 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54739 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54741 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54742 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54743 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54745 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54747 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54748 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54749 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54751 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54753 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54754 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54756 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54757 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54758 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54760 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54761 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54762 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54763 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54764 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54766 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54767 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54768 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54770 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54771 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54773 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54774 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54777 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54778 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54780 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54786 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54787 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54788 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54789 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54790 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54791 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54792 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54793 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54794 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54795 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54796 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54797 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54798 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54799 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54800 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54801 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54802 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54803 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54804 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54805 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54806 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54807 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54808 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54809 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54811 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54812 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54813 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54814 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54815 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54816 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54817 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54818 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54819 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54820 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54821 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54822 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54823 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54824 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54825 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54826 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54827 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54828 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54829 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54830 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54831 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54832 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54833 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54834 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54835 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54836 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54837 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54838 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54839 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54840 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54841 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54842 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54844 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54845 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54847 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54848 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54849 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54850 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54852 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54853 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54854 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54855 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54856 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54857 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54858 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54859 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54860 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54862 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54863 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54864 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54865 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54866 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54867 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54868 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54869 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54870 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54871 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54872 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54873 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54874 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54875 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54876 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54877 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54878 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54879 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54880 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54881 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54882 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54883 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54884 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54885 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54886 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54887 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54888 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54889 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54891 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54892 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54895 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54896 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54897 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54898 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54899 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54900 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54902 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54903 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54906 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54907 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54909 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54910 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54912 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54913 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54915 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54916 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54917 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54919 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54921 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54922 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54924 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54925 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54926 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54928 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54929 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54930 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54932 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54933 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54935 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54936 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54937 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54938 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54939 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54942 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54944 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54946 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54947 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54948 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54951 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54952 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54953 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54955 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54956 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54957 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54959 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54960 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54961 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54962 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54963 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54964 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54966 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54967 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54968 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54969 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54970 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54971 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54972 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54973 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54979 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54981 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54983 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54984 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54985 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54986 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54987 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54988 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54990 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54991 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54992 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54994 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54995 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54996 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54997 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54998 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
55001 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
55002 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
55003 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
55006 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
55007 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
55008 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
55009 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
55010 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
55012 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
55014 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
55017 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
55019 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
55020 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
55022 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
55023 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
55024 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
55026 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
55027 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
55028 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
55030 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
55032 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
55033 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
55034 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
55036 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
55038 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
55040 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
55041 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
55043 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
55044 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
55046 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
55048 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
55049 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
55050 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
55052 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
55054 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
55055 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
55056 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
55058 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
55060 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
55061 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
55062 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
55063 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
55065 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
55067 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
55069 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
55070 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
55071 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
55072 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
55074 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
55075 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
55076 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
55077 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
55078 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
55079 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
55080 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
55081 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
55082 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
55084 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
55086 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
55088 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
55090 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
55092 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
55094 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
55095 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
55096 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
55097 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
55098 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
55099 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55102 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
55104 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
55105 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
55106 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
55107 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
55108 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
55109 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
55110 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
55111 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
55112 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
55114 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
55116 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
55117 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
55119 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
55120 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
55121 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
55122 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
55124 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
55125 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
55126 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
55127 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
55129 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
55130 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
55131 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
55132 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
55133 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
55134 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
55136 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
55139 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
55140 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
55141 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
55142 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
55143 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
55145 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
55146 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
55148 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
55149 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
55150 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
55151 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
55153 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
55154 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
55155 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
55156 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
55157 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
55158 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
55159 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
55160 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
55161 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
55162 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
55164 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
55167 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
55168 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
55169 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
55171 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
55173 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
55174 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
55175 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
55177 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
55178 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
55181 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
55184 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
55185 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
55191 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
55192 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
55193 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
55196 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
55197 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
55198 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
55199 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
55200 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
55201 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
55202 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
55203 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
55204 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
55205 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
55206 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
55207 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
55208 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
55209 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
55210 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
55211 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
55212 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
55213 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
55216 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
55217 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55220 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
55222 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
55223 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55224 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
55225 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
55226 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
55227 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
55228 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
55229 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
55230 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
55232 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
55233 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
55234 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55235 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
55236 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55237 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
55238 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
55239 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
55240 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
55241 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55242 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
55243 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
55245 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
55247 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55249 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
55250 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
55251 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
55252 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
55253 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
55254 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
55255 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
55259 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
55260 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
55261 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
55262 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
55263 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
55264 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
55265 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
55269 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55270 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
55275 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
55276 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
55277 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
55278 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
55279 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
55281 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55284 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
55286 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
55287 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55288 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
55289 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
55290 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
55291 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
55292 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
55293 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
55294 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
55295 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
55296 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
55297 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
55298 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
55299 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
55300 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
55301 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
55303 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
55304 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
55305 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
55306 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55307 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
55308 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
55309 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55311 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55313 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55314 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
55315 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
55316 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
55317 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
55318 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
55320 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
55321 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
55323 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55324 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
55325 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
55326 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
55327 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
55328 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
55329 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
55330 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55331 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
55332 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
55333 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
55335 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
55336 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
55337 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
55338 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
55339 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
55340 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
55341 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55342 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
55343 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
55344 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
55345 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
55346 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55347 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
55348 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55349 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
55350 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
55351 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
55352 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55353 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
55354 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
55355 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
55356 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
55357 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
55358 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
55359 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
55360 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
55361 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55362 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
55363 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
55364 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
55365 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
55366 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
55367 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
55368 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
55369 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55370 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
55371 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
55372 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
55373 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
55374 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55375 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
55376 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
55377 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55378 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
55379 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
55380 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
55381 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
55382 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
55383 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
55384 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
55385 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
55386 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
55387 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55388 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
55389 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
55390 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
55391 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
55392 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
55393 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
55394 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
55395 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
55396 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55397 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
55398 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
55399 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
55400 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
55401 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
55402 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55403 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
55404 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
55405 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
55406 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55407 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
55408 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55409 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55410 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55411 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55412 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
55413 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55414 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55415 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
55416 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55417 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
55418 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55419 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55420 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55421 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55422 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
55423 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
55424 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
55425 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55426 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55427 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
55428 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55429 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
55430 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
55431 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
55432 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
55433 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
55434 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
55435 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
55436 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55437 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55438 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55439 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55440 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55441 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55442 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55443 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55444 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55445 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55446 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
55447 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
55448 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
55449 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
55450 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55451 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
55452 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
55453 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
55454 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
55455 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55456 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55457 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55458 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55459 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55460 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55461 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55462 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55463 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55464 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55465 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55466 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55467 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55468 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55469 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55470 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55471 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55472 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55473 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55474 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55475 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55476 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55477 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55478 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55479 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55480 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55481 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55482 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55483 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55484 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55485 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55486 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55487 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55488 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55489 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55490 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55491 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55492 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55493 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55494 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55495 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55496 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55497 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55498 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55499 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55500 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55501 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55502 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55503 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55504 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55505 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55506 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55507 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55508 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55509 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55510 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55511 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55512 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55513 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55514 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55515 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55516 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55517 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55518 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55519 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55520 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55521 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55522 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55523 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55524 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55525 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55526 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55527 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55528 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55529 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55530 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55531 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55532 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55533 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55534 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55535 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55536 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55537 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55538 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55539 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55540 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55541 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55542 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55543 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55544 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55545 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55546 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55547 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55548 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55549 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55550 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55551 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55552 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55553 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55554 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55555 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55556 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55557 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55558 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55559 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55560 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55561 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55562 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55563 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55564 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55565 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55566 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55567 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55568 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55569 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55570 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55571 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55572 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55573 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55574 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55575 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55576 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55577 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55578 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55579 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55580 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55581 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55582 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55583 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55584 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55585 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55586 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55587 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55588 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55589 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55590 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55591 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55592 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55593 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55594 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55595 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55596 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55597 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55598 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55599 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55600 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55601 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55602 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55603 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55604 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55605 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55606 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55607 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55608 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55609 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55610 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55611 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55612 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55613 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55614 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55615 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55616 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55617 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55618 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55619 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55620 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55621 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55622 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55623 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55624 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55625 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55626 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55627 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55628 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55629 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55630 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55631 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55632 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55633 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55634 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55635 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55636 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55637 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55638 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55639 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55640 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55641 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55642 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55643 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55644 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55645 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55646 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55647 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55648 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55649 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55650 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55651 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55652 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55653 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55654 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55655 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55656 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55657 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55658 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55659 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55660 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55661 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55662 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55663 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55664 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55665 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55666 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55667 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55668 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55669 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55670 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55671 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55672 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55673 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55674 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55675 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55676 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55677 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55678 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55679 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55680 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55681 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55682 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55683 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55684 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55685 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55686 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55687 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55688 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55689 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55690 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55691 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55692 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55693 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55694 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55695 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55696 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55697 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55698 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55699 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55700 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55701 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55702 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55703 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55704 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55705 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55706 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55707 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55708 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55709 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55710 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55711 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55712 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55713 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55714 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55715 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55716 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55717 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55718 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55719 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55720 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55721 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55722 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55723 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55724 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55725 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55726 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55727 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55728 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55729 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55730 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55731 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55732 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55733 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55734 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55735 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55736 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55737 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55738 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55739 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55740 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55741 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55742 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55743 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55744 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55745 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55746 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55747 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55748 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55749 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55750 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55751 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55752 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55753 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55754 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55755 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55756 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55757 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55758 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55759 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55760 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55761 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55762 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55763 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55764 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55765 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55766 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55767 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55768 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55769 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55770 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55771 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55772 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55773 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55774 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55775 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55776 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55777 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55778 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55779 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55780 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55781 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55782 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55783 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55784 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55785 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55786 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55787 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55788 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55789 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55790 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55791 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55792 { NULL, NULL, 0, NULL }
55793 };
55794
55795
55796 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55797
55798 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55799 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55800 }
55801 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55802 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55803 }
55804 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55805 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55806 }
55807 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55808 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55809 }
55810 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55811 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55812 }
55813 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55814 return (void *)((wxSizer *) ((wxGridSizer *) x));
55815 }
55816 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55817 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55818 }
55819 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55820 return (void *)((wxSizer *) ((wxPySizer *) x));
55821 }
55822 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55823 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55824 }
55825 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55826 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55827 }
55828 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55829 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55830 }
55831 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55832 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55833 }
55834 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55835 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55836 }
55837 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55838 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55839 }
55840 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55841 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55842 }
55843 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55844 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55845 }
55846 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55847 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55848 }
55849 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55850 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55851 }
55852 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55853 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55854 }
55855 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55856 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55857 }
55858 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55859 return (void *)((wxEvent *) ((wxPyEvent *) x));
55860 }
55861 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55862 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55863 }
55864 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55865 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55866 }
55867 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55868 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55869 }
55870 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55871 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55872 }
55873 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55874 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55875 }
55876 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55877 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55878 }
55879 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55880 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55881 }
55882 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55883 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55884 }
55885 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55886 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55887 }
55888 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55889 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55890 }
55891 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55892 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55893 }
55894 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55895 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55896 }
55897 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55898 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55899 }
55900 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55901 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55902 }
55903 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55904 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55905 }
55906 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55907 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55908 }
55909 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55910 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55911 }
55912 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55913 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55914 }
55915 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55916 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55917 }
55918 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55919 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55920 }
55921 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55922 return (void *)((wxEvent *) ((wxShowEvent *) x));
55923 }
55924 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55925 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55926 }
55927 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55928 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55929 }
55930 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55931 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55932 }
55933 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55934 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55935 }
55936 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55937 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55938 }
55939 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55940 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55941 }
55942 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55943 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55944 }
55945 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55946 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55947 }
55948 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55949 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55950 }
55951 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55952 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55953 }
55954 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55955 return (void *)((wxControl *) ((wxControlWithItems *) x));
55956 }
55957 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55958 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55959 }
55960 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55961 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55962 }
55963 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55964 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55965 }
55966 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55967 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55968 }
55969 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55970 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55971 }
55972 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55973 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55974 }
55975 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55976 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55977 }
55978 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55979 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55980 }
55981 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55982 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55983 }
55984 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55985 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55986 }
55987 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55988 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55989 }
55990 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55991 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55992 }
55993 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55994 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55995 }
55996 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55997 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55998 }
55999 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
56000 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
56001 }
56002 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
56003 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
56004 }
56005 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
56006 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
56007 }
56008 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
56009 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56010 }
56011 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
56012 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56013 }
56014 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
56015 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
56016 }
56017 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
56018 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
56019 }
56020 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
56021 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
56022 }
56023 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
56024 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
56025 }
56026 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
56027 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
56028 }
56029 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
56030 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
56031 }
56032 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
56033 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
56034 }
56035 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
56036 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
56037 }
56038 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
56039 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
56040 }
56041 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
56042 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
56043 }
56044 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
56045 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
56046 }
56047 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
56048 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
56049 }
56050 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
56051 return (void *)((wxObject *) ((wxSizerItem *) x));
56052 }
56053 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
56054 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
56055 }
56056 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
56057 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
56058 }
56059 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
56060 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
56061 }
56062 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
56063 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
56064 }
56065 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
56066 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
56067 }
56068 static void *_p_wxSizerTo_p_wxObject(void *x) {
56069 return (void *)((wxObject *) ((wxSizer *) x));
56070 }
56071 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
56072 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
56073 }
56074 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
56075 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
56076 }
56077 static void *_p_wxEventTo_p_wxObject(void *x) {
56078 return (void *)((wxObject *) ((wxEvent *) x));
56079 }
56080 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
56081 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
56082 }
56083 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
56084 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
56085 }
56086 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
56087 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
56088 }
56089 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
56090 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
56091 }
56092 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
56093 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
56094 }
56095 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
56096 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
56097 }
56098 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
56099 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
56100 }
56101 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
56102 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
56103 }
56104 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
56105 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
56106 }
56107 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
56108 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
56109 }
56110 static void *_p_wxControlTo_p_wxObject(void *x) {
56111 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
56112 }
56113 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
56114 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
56115 }
56116 static void *_p_wxFSFileTo_p_wxObject(void *x) {
56117 return (void *)((wxObject *) ((wxFSFile *) x));
56118 }
56119 static void *_p_wxPySizerTo_p_wxObject(void *x) {
56120 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
56121 }
56122 static void *_p_wxPyEventTo_p_wxObject(void *x) {
56123 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
56124 }
56125 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
56126 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
56127 }
56128 static void *_p_wxShowEventTo_p_wxObject(void *x) {
56129 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
56130 }
56131 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
56132 return (void *)((wxObject *) ((wxMenuItem *) x));
56133 }
56134 static void *_p_wxDateEventTo_p_wxObject(void *x) {
56135 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
56136 }
56137 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
56138 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
56139 }
56140 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
56141 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
56142 }
56143 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
56144 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
56145 }
56146 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
56147 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
56148 }
56149 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
56150 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
56151 }
56152 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
56153 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
56154 }
56155 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
56156 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
56157 }
56158 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
56159 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
56160 }
56161 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
56162 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
56163 }
56164 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
56165 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
56166 }
56167 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
56168 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
56169 }
56170 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
56171 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
56172 }
56173 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
56174 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
56175 }
56176 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
56177 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
56178 }
56179 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
56180 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
56181 }
56182 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
56183 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
56184 }
56185 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
56186 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
56187 }
56188 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
56189 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
56190 }
56191 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
56192 return (void *)((wxObject *) ((wxImageHandler *) x));
56193 }
56194 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
56195 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
56196 }
56197 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
56198 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
56199 }
56200 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
56201 return (void *)((wxObject *) ((wxEvtHandler *) x));
56202 }
56203 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
56204 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
56205 }
56206 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
56207 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
56208 }
56209 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
56210 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
56211 }
56212 static void *_p_wxImageTo_p_wxObject(void *x) {
56213 return (void *)((wxObject *) ((wxImage *) x));
56214 }
56215 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
56216 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
56217 }
56218 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
56219 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56220 }
56221 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
56222 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
56223 }
56224 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
56225 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
56226 }
56227 static void *_p_wxWindowTo_p_wxObject(void *x) {
56228 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
56229 }
56230 static void *_p_wxMenuTo_p_wxObject(void *x) {
56231 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
56232 }
56233 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
56234 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
56235 }
56236 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
56237 return (void *)((wxObject *) ((wxFileSystem *) x));
56238 }
56239 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
56240 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
56241 }
56242 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
56243 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
56244 }
56245 static void *_p_wxPyAppTo_p_wxObject(void *x) {
56246 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
56247 }
56248 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
56249 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
56250 }
56251 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
56252 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
56253 }
56254 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
56255 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
56256 }
56257 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
56258 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
56259 }
56260 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
56261 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
56262 }
56263 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
56264 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
56265 }
56266 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
56267 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
56268 }
56269 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
56270 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
56271 }
56272 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
56273 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
56274 }
56275 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
56276 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
56277 }
56278 static void *_p_wxValidatorTo_p_wxObject(void *x) {
56279 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
56280 }
56281 static void *_p_wxControlTo_p_wxWindow(void *x) {
56282 return (void *)((wxWindow *) ((wxControl *) x));
56283 }
56284 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
56285 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
56286 }
56287 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
56288 return (void *)((wxWindow *) ((wxMenuBar *) x));
56289 }
56290 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
56291 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
56292 }
56293 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
56294 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
56295 }
56296 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
56297 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
56298 }
56299 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
56300 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
56301 }
56302 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
56303 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
56304 }
56305 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
56306 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
56307 }
56308 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
56309 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
56310 }
56311 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
56312 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
56313 }
56314 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
56315 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
56316 }
56317 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
56318 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
56319 }
56320 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
56321 return (void *)((wxValidator *) ((wxPyValidator *) x));
56322 }
56323 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
56324 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
56325 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};
56326 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
56327 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
56328 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
56329 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
56330 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
56331 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
56332 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
56333 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
56334 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
56335 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
56336 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
56337 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
56338 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
56339 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
56340 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
56341 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
56342 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
56343 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
56344 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
56345 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
56346 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
56347 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
56348 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
56349 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
56350 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
56351 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
56352 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
56353 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
56354 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
56355 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
56356 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
56357 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
56358 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
56359 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
56360 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
56361 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
56362 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
56363 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
56364 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
56365 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
56366 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
56367 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
56368 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
56369 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
56370 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
56371 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
56372 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
56373 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
56374 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
56375 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
56376 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
56377 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
56378 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
56379 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
56380 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
56381 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
56382 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
56383 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
56384 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
56385 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
56386 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
56387 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
56388 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
56389 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
56390 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
56391 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
56392 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
56393 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
56394 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
56395 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
56396 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
56397 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
56398 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
56399 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
56400 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
56401 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
56402 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
56403 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
56404 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
56405 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
56406 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
56407 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
56408 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
56409 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
56410 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
56411 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
56412 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
56413 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
56414 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
56415 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
56416 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
56417 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
56418 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
56419 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
56420 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
56421 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
56422 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
56423 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
56424 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
56425 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
56426 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
56427 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
56428 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
56429 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
56430 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
56431 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
56432 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
56433 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
56434 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
56435 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
56436 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
56437 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
56438 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
56439 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
56440 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
56441 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
56442 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
56443 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
56444 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
56445 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
56446 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
56447 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
56448 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
56449 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
56450 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
56451 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
56452 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
56453 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
56454 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56455
56456 static swig_type_info *swig_type_initial[] = {
56457 &_swigt__p_buffer,
56458 &_swigt__p_char,
56459 &_swigt__p_form_ops_t,
56460 &_swigt__p_int,
56461 &_swigt__p_long,
56462 &_swigt__p_unsigned_char,
56463 &_swigt__p_unsigned_int,
56464 &_swigt__p_unsigned_long,
56465 &_swigt__p_wxANIHandler,
56466 &_swigt__p_wxAcceleratorEntry,
56467 &_swigt__p_wxAcceleratorTable,
56468 &_swigt__p_wxActivateEvent,
56469 &_swigt__p_wxAppTraits,
56470 &_swigt__p_wxArrayString,
56471 &_swigt__p_wxBMPHandler,
56472 &_swigt__p_wxBitmap,
56473 &_swigt__p_wxBoxSizer,
56474 &_swigt__p_wxButton,
56475 &_swigt__p_wxCURHandler,
56476 &_swigt__p_wxCaret,
56477 &_swigt__p_wxChildFocusEvent,
56478 &_swigt__p_wxClipboardTextEvent,
56479 &_swigt__p_wxCloseEvent,
56480 &_swigt__p_wxColour,
56481 &_swigt__p_wxCommandEvent,
56482 &_swigt__p_wxContextMenuEvent,
56483 &_swigt__p_wxControl,
56484 &_swigt__p_wxControlWithItems,
56485 &_swigt__p_wxCursor,
56486 &_swigt__p_wxDC,
56487 &_swigt__p_wxDateEvent,
56488 &_swigt__p_wxDateTime,
56489 &_swigt__p_wxDisplayChangedEvent,
56490 &_swigt__p_wxDropFilesEvent,
56491 &_swigt__p_wxDuplexMode,
56492 &_swigt__p_wxEraseEvent,
56493 &_swigt__p_wxEvent,
56494 &_swigt__p_wxEventLoop,
56495 &_swigt__p_wxEventLoopActivator,
56496 &_swigt__p_wxEvtHandler,
56497 &_swigt__p_wxFSFile,
56498 &_swigt__p_wxFileSystem,
56499 &_swigt__p_wxFileSystemHandler,
56500 &_swigt__p_wxFlexGridSizer,
56501 &_swigt__p_wxFocusEvent,
56502 &_swigt__p_wxFont,
56503 &_swigt__p_wxFrame,
56504 &_swigt__p_wxGBPosition,
56505 &_swigt__p_wxGBSizerItem,
56506 &_swigt__p_wxGBSpan,
56507 &_swigt__p_wxGIFHandler,
56508 &_swigt__p_wxGridBagSizer,
56509 &_swigt__p_wxGridSizer,
56510 &_swigt__p_wxHelpEvent__Origin,
56511 &_swigt__p_wxICOHandler,
56512 &_swigt__p_wxIconizeEvent,
56513 &_swigt__p_wxIdleEvent,
56514 &_swigt__p_wxImage,
56515 &_swigt__p_wxImageHandler,
56516 &_swigt__p_wxImageHistogram,
56517 &_swigt__p_wxImage_HSVValue,
56518 &_swigt__p_wxImage_RGBValue,
56519 &_swigt__p_wxIndividualLayoutConstraint,
56520 &_swigt__p_wxInitDialogEvent,
56521 &_swigt__p_wxInputStream,
56522 &_swigt__p_wxInternetFSHandler,
56523 &_swigt__p_wxItemContainer,
56524 &_swigt__p_wxJPEGHandler,
56525 &_swigt__p_wxKeyEvent,
56526 &_swigt__p_wxLayoutConstraints,
56527 &_swigt__p_wxMaximizeEvent,
56528 &_swigt__p_wxMemoryFSHandler,
56529 &_swigt__p_wxMenu,
56530 &_swigt__p_wxMenuBar,
56531 &_swigt__p_wxMenuBarBase,
56532 &_swigt__p_wxMenuEvent,
56533 &_swigt__p_wxMenuItem,
56534 &_swigt__p_wxMouseCaptureChangedEvent,
56535 &_swigt__p_wxMouseCaptureLostEvent,
56536 &_swigt__p_wxMouseEvent,
56537 &_swigt__p_wxMoveEvent,
56538 &_swigt__p_wxNavigationKeyEvent,
56539 &_swigt__p_wxNcPaintEvent,
56540 &_swigt__p_wxNotifyEvent,
56541 &_swigt__p_wxObject,
56542 &_swigt__p_wxOutputStream,
56543 &_swigt__p_wxPCXHandler,
56544 &_swigt__p_wxPNGHandler,
56545 &_swigt__p_wxPNMHandler,
56546 &_swigt__p_wxPaintEvent,
56547 &_swigt__p_wxPaletteChangedEvent,
56548 &_swigt__p_wxPaperSize,
56549 &_swigt__p_wxPoint,
56550 &_swigt__p_wxPoint2D,
56551 &_swigt__p_wxPropagateOnce,
56552 &_swigt__p_wxPropagationDisabler,
56553 &_swigt__p_wxPyApp,
56554 &_swigt__p_wxPyCommandEvent,
56555 &_swigt__p_wxPyDropTarget,
56556 &_swigt__p_wxPyEvent,
56557 &_swigt__p_wxPyFileSystemHandler,
56558 &_swigt__p_wxPyImageHandler,
56559 &_swigt__p_wxPyInputStream,
56560 &_swigt__p_wxPySizer,
56561 &_swigt__p_wxPyValidator,
56562 &_swigt__p_wxQuantize,
56563 &_swigt__p_wxQueryNewPaletteEvent,
56564 &_swigt__p_wxRealPoint,
56565 &_swigt__p_wxRect,
56566 &_swigt__p_wxRegion,
56567 &_swigt__p_wxScrollEvent,
56568 &_swigt__p_wxScrollWinEvent,
56569 &_swigt__p_wxSetCursorEvent,
56570 &_swigt__p_wxShowEvent,
56571 &_swigt__p_wxSize,
56572 &_swigt__p_wxSizeEvent,
56573 &_swigt__p_wxSizer,
56574 &_swigt__p_wxSizerItem,
56575 &_swigt__p_wxStaticBox,
56576 &_swigt__p_wxStaticBoxSizer,
56577 &_swigt__p_wxStdDialogButtonSizer,
56578 &_swigt__p_wxSysColourChangedEvent,
56579 &_swigt__p_wxTIFFHandler,
56580 &_swigt__p_wxToolTip,
56581 &_swigt__p_wxUpdateUIEvent,
56582 &_swigt__p_wxValidator,
56583 &_swigt__p_wxVisualAttributes,
56584 &_swigt__p_wxWindow,
56585 &_swigt__p_wxWindowCreateEvent,
56586 &_swigt__p_wxWindowDestroyEvent,
56587 &_swigt__p_wxXPMHandler,
56588 &_swigt__p_wxZipFSHandler,
56589 };
56590
56591 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56592 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56593 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56594 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56595 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56596 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56597 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56598 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56599 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56600 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56601 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56602 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56603 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56604 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56605 static swig_cast_info _swigc__p_wxBMPHandler[] = { {&_swigt__p_wxBMPHandler, 0, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxBMPHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxBMPHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxBMPHandler, 0, 0},{0, 0, 0, 0}};
56606 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56607 static swig_cast_info _swigc__p_wxBoxSizer[] = { {&_swigt__p_wxBoxSizer, 0, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxBoxSizer, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxBoxSizer, 0, 0},{0, 0, 0, 0}};
56608 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56609 static swig_cast_info _swigc__p_wxCURHandler[] = { {&_swigt__p_wxCURHandler, 0, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxCURHandler, 0, 0},{0, 0, 0, 0}};
56610 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56611 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56612 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56613 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56614 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56615 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
56616 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56617 static swig_cast_info _swigc__p_wxControl[] = { {&_swigt__p_wxControl, 0, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxControl, 0, 0},{0, 0, 0, 0}};
56618 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56619 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56620 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56621 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56622 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56623 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56624 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56625 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56626 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56627 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_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_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}};
56628 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56629 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56630 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_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},{0, 0, 0, 0}};
56631 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56632 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56633 static swig_cast_info _swigc__p_wxFileSystemHandler[] = { {&_swigt__p_wxFileSystemHandler, 0, 0, 0}, {&_swigt__p_wxPyFileSystemHandler, _p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxInternetFSHandler, _p_wxInternetFSHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxZipFSHandler, _p_wxZipFSHandlerTo_p_wxFileSystemHandler, 0, 0}, {&_swigt__p_wxMemoryFSHandler, _p_wxMemoryFSHandlerTo_p_wxFileSystemHandler, 0, 0},{0, 0, 0, 0}};
56634 static swig_cast_info _swigc__p_wxFlexGridSizer[] = { {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxFlexGridSizer, 0, 0}, {&_swigt__p_wxFlexGridSizer, 0, 0, 0},{0, 0, 0, 0}};
56635 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56636 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56637 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56638 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56639 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56640 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56641 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56642 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56643 static swig_cast_info _swigc__p_wxGridSizer[] = { {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxGridSizer, 0, 0}, {&_swigt__p_wxGridSizer, 0, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxGridSizer, 0, 0},{0, 0, 0, 0}};
56644 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56645 static swig_cast_info _swigc__p_wxICOHandler[] = { {&_swigt__p_wxICOHandler, 0, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxICOHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxICOHandler, 0, 0},{0, 0, 0, 0}};
56646 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56647 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56648 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56649 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
56650 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56651 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56652 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56653 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56654 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56655 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56656 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56657 static swig_cast_info _swigc__p_wxItemContainer[] = { {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxItemContainer, 0, 0}, {&_swigt__p_wxItemContainer, 0, 0, 0},{0, 0, 0, 0}};
56658 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56659 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56660 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56661 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56662 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56663 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56664 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56665 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56666 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56667 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56668 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56669 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56670 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56671 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56672 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56673 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56674 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56675 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_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_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_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_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_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_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},{0, 0, 0, 0}};
56676 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56677 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56678 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56679 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56680 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56681 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56682 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56683 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56684 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56685 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56686 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56687 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56688 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56689 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56690 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56691 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56692 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56693 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56694 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56695 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56696 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56697 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56698 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56699 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56700 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56701 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56702 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56703 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56704 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56705 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56706 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56707 static swig_cast_info _swigc__p_wxSizer[] = { {&_swigt__p_wxSizer, 0, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxSizer, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxSizer, 0, 0},{0, 0, 0, 0}};
56708 static swig_cast_info _swigc__p_wxSizerItem[] = { {&_swigt__p_wxSizerItem, 0, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxSizerItem, 0, 0},{0, 0, 0, 0}};
56709 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56710 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56711 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56712 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56713 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56714 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56715 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56716 static swig_cast_info _swigc__p_wxValidator[] = { {&_swigt__p_wxValidator, 0, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxValidator, 0, 0},{0, 0, 0, 0}};
56717 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56718 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}};
56719 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56720 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56721 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56722 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56723
56724 static swig_cast_info *swig_cast_initial[] = {
56725 _swigc__p_buffer,
56726 _swigc__p_char,
56727 _swigc__p_form_ops_t,
56728 _swigc__p_int,
56729 _swigc__p_long,
56730 _swigc__p_unsigned_char,
56731 _swigc__p_unsigned_int,
56732 _swigc__p_unsigned_long,
56733 _swigc__p_wxANIHandler,
56734 _swigc__p_wxAcceleratorEntry,
56735 _swigc__p_wxAcceleratorTable,
56736 _swigc__p_wxActivateEvent,
56737 _swigc__p_wxAppTraits,
56738 _swigc__p_wxArrayString,
56739 _swigc__p_wxBMPHandler,
56740 _swigc__p_wxBitmap,
56741 _swigc__p_wxBoxSizer,
56742 _swigc__p_wxButton,
56743 _swigc__p_wxCURHandler,
56744 _swigc__p_wxCaret,
56745 _swigc__p_wxChildFocusEvent,
56746 _swigc__p_wxClipboardTextEvent,
56747 _swigc__p_wxCloseEvent,
56748 _swigc__p_wxColour,
56749 _swigc__p_wxCommandEvent,
56750 _swigc__p_wxContextMenuEvent,
56751 _swigc__p_wxControl,
56752 _swigc__p_wxControlWithItems,
56753 _swigc__p_wxCursor,
56754 _swigc__p_wxDC,
56755 _swigc__p_wxDateEvent,
56756 _swigc__p_wxDateTime,
56757 _swigc__p_wxDisplayChangedEvent,
56758 _swigc__p_wxDropFilesEvent,
56759 _swigc__p_wxDuplexMode,
56760 _swigc__p_wxEraseEvent,
56761 _swigc__p_wxEvent,
56762 _swigc__p_wxEventLoop,
56763 _swigc__p_wxEventLoopActivator,
56764 _swigc__p_wxEvtHandler,
56765 _swigc__p_wxFSFile,
56766 _swigc__p_wxFileSystem,
56767 _swigc__p_wxFileSystemHandler,
56768 _swigc__p_wxFlexGridSizer,
56769 _swigc__p_wxFocusEvent,
56770 _swigc__p_wxFont,
56771 _swigc__p_wxFrame,
56772 _swigc__p_wxGBPosition,
56773 _swigc__p_wxGBSizerItem,
56774 _swigc__p_wxGBSpan,
56775 _swigc__p_wxGIFHandler,
56776 _swigc__p_wxGridBagSizer,
56777 _swigc__p_wxGridSizer,
56778 _swigc__p_wxHelpEvent__Origin,
56779 _swigc__p_wxICOHandler,
56780 _swigc__p_wxIconizeEvent,
56781 _swigc__p_wxIdleEvent,
56782 _swigc__p_wxImage,
56783 _swigc__p_wxImageHandler,
56784 _swigc__p_wxImageHistogram,
56785 _swigc__p_wxImage_HSVValue,
56786 _swigc__p_wxImage_RGBValue,
56787 _swigc__p_wxIndividualLayoutConstraint,
56788 _swigc__p_wxInitDialogEvent,
56789 _swigc__p_wxInputStream,
56790 _swigc__p_wxInternetFSHandler,
56791 _swigc__p_wxItemContainer,
56792 _swigc__p_wxJPEGHandler,
56793 _swigc__p_wxKeyEvent,
56794 _swigc__p_wxLayoutConstraints,
56795 _swigc__p_wxMaximizeEvent,
56796 _swigc__p_wxMemoryFSHandler,
56797 _swigc__p_wxMenu,
56798 _swigc__p_wxMenuBar,
56799 _swigc__p_wxMenuBarBase,
56800 _swigc__p_wxMenuEvent,
56801 _swigc__p_wxMenuItem,
56802 _swigc__p_wxMouseCaptureChangedEvent,
56803 _swigc__p_wxMouseCaptureLostEvent,
56804 _swigc__p_wxMouseEvent,
56805 _swigc__p_wxMoveEvent,
56806 _swigc__p_wxNavigationKeyEvent,
56807 _swigc__p_wxNcPaintEvent,
56808 _swigc__p_wxNotifyEvent,
56809 _swigc__p_wxObject,
56810 _swigc__p_wxOutputStream,
56811 _swigc__p_wxPCXHandler,
56812 _swigc__p_wxPNGHandler,
56813 _swigc__p_wxPNMHandler,
56814 _swigc__p_wxPaintEvent,
56815 _swigc__p_wxPaletteChangedEvent,
56816 _swigc__p_wxPaperSize,
56817 _swigc__p_wxPoint,
56818 _swigc__p_wxPoint2D,
56819 _swigc__p_wxPropagateOnce,
56820 _swigc__p_wxPropagationDisabler,
56821 _swigc__p_wxPyApp,
56822 _swigc__p_wxPyCommandEvent,
56823 _swigc__p_wxPyDropTarget,
56824 _swigc__p_wxPyEvent,
56825 _swigc__p_wxPyFileSystemHandler,
56826 _swigc__p_wxPyImageHandler,
56827 _swigc__p_wxPyInputStream,
56828 _swigc__p_wxPySizer,
56829 _swigc__p_wxPyValidator,
56830 _swigc__p_wxQuantize,
56831 _swigc__p_wxQueryNewPaletteEvent,
56832 _swigc__p_wxRealPoint,
56833 _swigc__p_wxRect,
56834 _swigc__p_wxRegion,
56835 _swigc__p_wxScrollEvent,
56836 _swigc__p_wxScrollWinEvent,
56837 _swigc__p_wxSetCursorEvent,
56838 _swigc__p_wxShowEvent,
56839 _swigc__p_wxSize,
56840 _swigc__p_wxSizeEvent,
56841 _swigc__p_wxSizer,
56842 _swigc__p_wxSizerItem,
56843 _swigc__p_wxStaticBox,
56844 _swigc__p_wxStaticBoxSizer,
56845 _swigc__p_wxStdDialogButtonSizer,
56846 _swigc__p_wxSysColourChangedEvent,
56847 _swigc__p_wxTIFFHandler,
56848 _swigc__p_wxToolTip,
56849 _swigc__p_wxUpdateUIEvent,
56850 _swigc__p_wxValidator,
56851 _swigc__p_wxVisualAttributes,
56852 _swigc__p_wxWindow,
56853 _swigc__p_wxWindowCreateEvent,
56854 _swigc__p_wxWindowDestroyEvent,
56855 _swigc__p_wxXPMHandler,
56856 _swigc__p_wxZipFSHandler,
56857 };
56858
56859
56860 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56861
56862 static swig_const_info swig_const_table[] = {
56863 {0, 0, 0, 0.0, 0, 0}};
56864
56865 #ifdef __cplusplus
56866 }
56867 #endif
56868 /* -----------------------------------------------------------------------------
56869 * Type initialization:
56870 * This problem is tough by the requirement that no dynamic
56871 * memory is used. Also, since swig_type_info structures store pointers to
56872 * swig_cast_info structures and swig_cast_info structures store pointers back
56873 * to swig_type_info structures, we need some lookup code at initialization.
56874 * The idea is that swig generates all the structures that are needed.
56875 * The runtime then collects these partially filled structures.
56876 * The SWIG_InitializeModule function takes these initial arrays out of
56877 * swig_module, and does all the lookup, filling in the swig_module.types
56878 * array with the correct data and linking the correct swig_cast_info
56879 * structures together.
56880 *
56881 * The generated swig_type_info structures are assigned staticly to an initial
56882 * array. We just loop though that array, and handle each type individually.
56883 * First we lookup if this type has been already loaded, and if so, use the
56884 * loaded structure instead of the generated one. Then we have to fill in the
56885 * cast linked list. The cast data is initially stored in something like a
56886 * two-dimensional array. Each row corresponds to a type (there are the same
56887 * number of rows as there are in the swig_type_initial array). Each entry in
56888 * a column is one of the swig_cast_info structures for that type.
56889 * The cast_initial array is actually an array of arrays, because each row has
56890 * a variable number of columns. So to actually build the cast linked list,
56891 * we find the array of casts associated with the type, and loop through it
56892 * adding the casts to the list. The one last trick we need to do is making
56893 * sure the type pointer in the swig_cast_info struct is correct.
56894 *
56895 * First off, we lookup the cast->type name to see if it is already loaded.
56896 * There are three cases to handle:
56897 * 1) If the cast->type has already been loaded AND the type we are adding
56898 * casting info to has not been loaded (it is in this module), THEN we
56899 * replace the cast->type pointer with the type pointer that has already
56900 * been loaded.
56901 * 2) If BOTH types (the one we are adding casting info to, and the
56902 * cast->type) are loaded, THEN the cast info has already been loaded by
56903 * the previous module so we just ignore it.
56904 * 3) Finally, if cast->type has not already been loaded, then we add that
56905 * swig_cast_info to the linked list (because the cast->type) pointer will
56906 * be correct.
56907 * ----------------------------------------------------------------------------- */
56908
56909 #ifdef __cplusplus
56910 extern "C" {
56911 #if 0
56912 } /* c-mode */
56913 #endif
56914 #endif
56915
56916 #if 0
56917 #define SWIGRUNTIME_DEBUG
56918 #endif
56919
56920 SWIGRUNTIME void
56921 SWIG_InitializeModule(void *clientdata) {
56922 size_t i;
56923 swig_module_info *module_head;
56924 static int init_run = 0;
56925
56926 clientdata = clientdata;
56927
56928 if (init_run) return;
56929 init_run = 1;
56930
56931 /* Initialize the swig_module */
56932 swig_module.type_initial = swig_type_initial;
56933 swig_module.cast_initial = swig_cast_initial;
56934
56935 /* Try and load any already created modules */
56936 module_head = SWIG_GetModule(clientdata);
56937 if (module_head) {
56938 swig_module.next = module_head->next;
56939 module_head->next = &swig_module;
56940 } else {
56941 /* This is the first module loaded */
56942 swig_module.next = &swig_module;
56943 SWIG_SetModule(clientdata, &swig_module);
56944 }
56945
56946 /* Now work on filling in swig_module.types */
56947 #ifdef SWIGRUNTIME_DEBUG
56948 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56949 #endif
56950 for (i = 0; i < swig_module.size; ++i) {
56951 swig_type_info *type = 0;
56952 swig_type_info *ret;
56953 swig_cast_info *cast;
56954
56955 #ifdef SWIGRUNTIME_DEBUG
56956 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56957 #endif
56958
56959 /* if there is another module already loaded */
56960 if (swig_module.next != &swig_module) {
56961 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56962 }
56963 if (type) {
56964 /* Overwrite clientdata field */
56965 #ifdef SWIGRUNTIME_DEBUG
56966 printf("SWIG_InitializeModule: found type %s\n", type->name);
56967 #endif
56968 if (swig_module.type_initial[i]->clientdata) {
56969 type->clientdata = swig_module.type_initial[i]->clientdata;
56970 #ifdef SWIGRUNTIME_DEBUG
56971 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56972 #endif
56973 }
56974 } else {
56975 type = swig_module.type_initial[i];
56976 }
56977
56978 /* Insert casting types */
56979 cast = swig_module.cast_initial[i];
56980 while (cast->type) {
56981 /* Don't need to add information already in the list */
56982 ret = 0;
56983 #ifdef SWIGRUNTIME_DEBUG
56984 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56985 #endif
56986 if (swig_module.next != &swig_module) {
56987 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56988 #ifdef SWIGRUNTIME_DEBUG
56989 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56990 #endif
56991 }
56992 if (ret) {
56993 if (type == swig_module.type_initial[i]) {
56994 #ifdef SWIGRUNTIME_DEBUG
56995 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56996 #endif
56997 cast->type = ret;
56998 ret = 0;
56999 } else {
57000 /* Check for casting already in the list */
57001 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
57002 #ifdef SWIGRUNTIME_DEBUG
57003 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
57004 #endif
57005 if (!ocast) ret = 0;
57006 }
57007 }
57008
57009 if (!ret) {
57010 #ifdef SWIGRUNTIME_DEBUG
57011 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
57012 #endif
57013 if (type->cast) {
57014 type->cast->prev = cast;
57015 cast->next = type->cast;
57016 }
57017 type->cast = cast;
57018 }
57019 cast++;
57020 }
57021 /* Set entry in modules->types array equal to the type */
57022 swig_module.types[i] = type;
57023 }
57024 swig_module.types[i] = 0;
57025
57026 #ifdef SWIGRUNTIME_DEBUG
57027 printf("**** SWIG_InitializeModule: Cast List ******\n");
57028 for (i = 0; i < swig_module.size; ++i) {
57029 int j = 0;
57030 swig_cast_info *cast = swig_module.cast_initial[i];
57031 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
57032 while (cast->type) {
57033 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
57034 cast++;
57035 ++j;
57036 }
57037 printf("---- Total casts: %d\n",j);
57038 }
57039 printf("**** SWIG_InitializeModule: Cast List ******\n");
57040 #endif
57041 }
57042
57043 /* This function will propagate the clientdata field of type to
57044 * any new swig_type_info structures that have been added into the list
57045 * of equivalent types. It is like calling
57046 * SWIG_TypeClientData(type, clientdata) a second time.
57047 */
57048 SWIGRUNTIME void
57049 SWIG_PropagateClientData(void) {
57050 size_t i;
57051 swig_cast_info *equiv;
57052 static int init_run = 0;
57053
57054 if (init_run) return;
57055 init_run = 1;
57056
57057 for (i = 0; i < swig_module.size; i++) {
57058 if (swig_module.types[i]->clientdata) {
57059 equiv = swig_module.types[i]->cast;
57060 while (equiv) {
57061 if (!equiv->converter) {
57062 if (equiv->type && !equiv->type->clientdata)
57063 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
57064 }
57065 equiv = equiv->next;
57066 }
57067 }
57068 }
57069 }
57070
57071 #ifdef __cplusplus
57072 #if 0
57073 {
57074 /* c-mode */
57075 #endif
57076 }
57077 #endif
57078
57079
57080
57081 #ifdef __cplusplus
57082 extern "C" {
57083 #endif
57084
57085 /* Python-specific SWIG API */
57086 #define SWIG_newvarlink() SWIG_Python_newvarlink()
57087 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
57088 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
57089
57090 /* -----------------------------------------------------------------------------
57091 * global variable support code.
57092 * ----------------------------------------------------------------------------- */
57093
57094 typedef struct swig_globalvar {
57095 char *name; /* Name of global variable */
57096 PyObject *(*get_attr)(void); /* Return the current value */
57097 int (*set_attr)(PyObject *); /* Set the value */
57098 struct swig_globalvar *next;
57099 } swig_globalvar;
57100
57101 typedef struct swig_varlinkobject {
57102 PyObject_HEAD
57103 swig_globalvar *vars;
57104 } swig_varlinkobject;
57105
57106 SWIGINTERN PyObject *
57107 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
57108 return PyString_FromString("<Swig global variables>");
57109 }
57110
57111 SWIGINTERN PyObject *
57112 swig_varlink_str(swig_varlinkobject *v) {
57113 PyObject *str = PyString_FromString("(");
57114 swig_globalvar *var;
57115 for (var = v->vars; var; var=var->next) {
57116 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
57117 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
57118 }
57119 PyString_ConcatAndDel(&str,PyString_FromString(")"));
57120 return str;
57121 }
57122
57123 SWIGINTERN int
57124 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
57125 PyObject *str = swig_varlink_str(v);
57126 fprintf(fp,"Swig global variables ");
57127 fprintf(fp,"%s\n", PyString_AsString(str));
57128 Py_DECREF(str);
57129 return 0;
57130 }
57131
57132 SWIGINTERN void
57133 swig_varlink_dealloc(swig_varlinkobject *v) {
57134 swig_globalvar *var = v->vars;
57135 while (var) {
57136 swig_globalvar *n = var->next;
57137 free(var->name);
57138 free(var);
57139 var = n;
57140 }
57141 }
57142
57143 SWIGINTERN PyObject *
57144 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
57145 PyObject *res = NULL;
57146 swig_globalvar *var = v->vars;
57147 while (var) {
57148 if (strcmp(var->name,n) == 0) {
57149 res = (*var->get_attr)();
57150 break;
57151 }
57152 var = var->next;
57153 }
57154 if (res == NULL && !PyErr_Occurred()) {
57155 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57156 }
57157 return res;
57158 }
57159
57160 SWIGINTERN int
57161 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
57162 int res = 1;
57163 swig_globalvar *var = v->vars;
57164 while (var) {
57165 if (strcmp(var->name,n) == 0) {
57166 res = (*var->set_attr)(p);
57167 break;
57168 }
57169 var = var->next;
57170 }
57171 if (res == 1 && !PyErr_Occurred()) {
57172 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
57173 }
57174 return res;
57175 }
57176
57177 SWIGINTERN PyTypeObject*
57178 swig_varlink_type(void) {
57179 static char varlink__doc__[] = "Swig var link object";
57180 static PyTypeObject varlink_type;
57181 static int type_init = 0;
57182 if (!type_init) {
57183 const PyTypeObject tmp
57184 = {
57185 PyObject_HEAD_INIT(NULL)
57186 0, /* Number of items in variable part (ob_size) */
57187 (char *)"swigvarlink", /* Type name (tp_name) */
57188 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
57189 0, /* Itemsize (tp_itemsize) */
57190 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
57191 (printfunc) swig_varlink_print, /* Print (tp_print) */
57192 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
57193 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
57194 0, /* tp_compare */
57195 (reprfunc) swig_varlink_repr, /* tp_repr */
57196 0, /* tp_as_number */
57197 0, /* tp_as_sequence */
57198 0, /* tp_as_mapping */
57199 0, /* tp_hash */
57200 0, /* tp_call */
57201 (reprfunc)swig_varlink_str, /* tp_str */
57202 0, /* tp_getattro */
57203 0, /* tp_setattro */
57204 0, /* tp_as_buffer */
57205 0, /* tp_flags */
57206 varlink__doc__, /* tp_doc */
57207 0, /* tp_traverse */
57208 0, /* tp_clear */
57209 0, /* tp_richcompare */
57210 0, /* tp_weaklistoffset */
57211 #if PY_VERSION_HEX >= 0x02020000
57212 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
57213 #endif
57214 #if PY_VERSION_HEX >= 0x02030000
57215 0, /* tp_del */
57216 #endif
57217 #ifdef COUNT_ALLOCS
57218 0,0,0,0 /* tp_alloc -> tp_next */
57219 #endif
57220 };
57221 varlink_type = tmp;
57222 varlink_type.ob_type = &PyType_Type;
57223 type_init = 1;
57224 }
57225 return &varlink_type;
57226 }
57227
57228 /* Create a variable linking object for use later */
57229 SWIGINTERN PyObject *
57230 SWIG_Python_newvarlink(void) {
57231 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
57232 if (result) {
57233 result->vars = 0;
57234 }
57235 return ((PyObject*) result);
57236 }
57237
57238 SWIGINTERN void
57239 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
57240 swig_varlinkobject *v = (swig_varlinkobject *) p;
57241 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
57242 if (gv) {
57243 size_t size = strlen(name)+1;
57244 gv->name = (char *)malloc(size);
57245 if (gv->name) {
57246 strncpy(gv->name,name,size);
57247 gv->get_attr = get_attr;
57248 gv->set_attr = set_attr;
57249 gv->next = v->vars;
57250 }
57251 }
57252 v->vars = gv;
57253 }
57254
57255 SWIGINTERN PyObject *
57256 SWIG_globals() {
57257 static PyObject *_SWIG_globals = 0;
57258 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
57259 return _SWIG_globals;
57260 }
57261
57262 /* -----------------------------------------------------------------------------
57263 * constants/methods manipulation
57264 * ----------------------------------------------------------------------------- */
57265
57266 /* Install Constants */
57267 SWIGINTERN void
57268 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
57269 PyObject *obj = 0;
57270 size_t i;
57271 for (i = 0; constants[i].type; ++i) {
57272 switch(constants[i].type) {
57273 case SWIG_PY_POINTER:
57274 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
57275 break;
57276 case SWIG_PY_BINARY:
57277 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
57278 break;
57279 default:
57280 obj = 0;
57281 break;
57282 }
57283 if (obj) {
57284 PyDict_SetItemString(d, constants[i].name, obj);
57285 Py_DECREF(obj);
57286 }
57287 }
57288 }
57289
57290 /* -----------------------------------------------------------------------------*/
57291 /* Fix SwigMethods to carry the callback ptrs when needed */
57292 /* -----------------------------------------------------------------------------*/
57293
57294 SWIGINTERN void
57295 SWIG_Python_FixMethods(PyMethodDef *methods,
57296 swig_const_info *const_table,
57297 swig_type_info **types,
57298 swig_type_info **types_initial) {
57299 size_t i;
57300 for (i = 0; methods[i].ml_name; ++i) {
57301 const char *c = methods[i].ml_doc;
57302 if (c && (c = strstr(c, "swig_ptr: "))) {
57303 int j;
57304 swig_const_info *ci = 0;
57305 const char *name = c + 10;
57306 for (j = 0; const_table[j].type; ++j) {
57307 if (strncmp(const_table[j].name, name,
57308 strlen(const_table[j].name)) == 0) {
57309 ci = &(const_table[j]);
57310 break;
57311 }
57312 }
57313 if (ci) {
57314 size_t shift = (ci->ptype) - types;
57315 swig_type_info *ty = types_initial[shift];
57316 size_t ldoc = (c - methods[i].ml_doc);
57317 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
57318 char *ndoc = (char*)malloc(ldoc + lptr + 10);
57319 if (ndoc) {
57320 char *buff = ndoc;
57321 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
57322 if (ptr) {
57323 strncpy(buff, methods[i].ml_doc, ldoc);
57324 buff += ldoc;
57325 strncpy(buff, "swig_ptr: ", 10);
57326 buff += 10;
57327 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
57328 methods[i].ml_doc = ndoc;
57329 }
57330 }
57331 }
57332 }
57333 }
57334 }
57335
57336 #ifdef __cplusplus
57337 }
57338 #endif
57339
57340 /* -----------------------------------------------------------------------------*
57341 * Partial Init method
57342 * -----------------------------------------------------------------------------*/
57343
57344 #ifdef __cplusplus
57345 extern "C"
57346 #endif
57347 SWIGEXPORT void SWIG_init(void) {
57348 PyObject *m, *d;
57349
57350 /* Fix SwigMethods to carry the callback ptrs when needed */
57351 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
57352
57353 m = Py_InitModule((char *) SWIG_name, SwigMethods);
57354 d = PyModule_GetDict(m);
57355
57356 SWIG_InitializeModule(0);
57357 SWIG_InstallConstants(d,swig_const_table);
57358
57359
57360
57361 #ifndef wxPyUSE_EXPORT
57362 // Make our API structure a CObject so other modules can import it
57363 // from this module.
57364 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
57365 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
57366 Py_XDECREF(cobj);
57367 #endif
57368
57369 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
57370 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
57371 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
57372 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
57373 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
57374 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
57375 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
57376 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
57377 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
57378 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
57379 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
57380 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
57381 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
57382 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
57383 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
57384 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
57385 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
57386 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
57387 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
57388 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
57389 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
57390 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
57391 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
57392 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
57393 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
57394 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
57395 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
57396 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
57397 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
57398 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
57399 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
57400 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
57401 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
57402 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
57403 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
57404 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
57405 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
57406 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
57407 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
57408 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
57409 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
57410 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
57411 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
57412 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
57413 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
57414 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
57415 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
57416 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
57417 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
57418 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
57419 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
57420 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
57421 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
57422 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
57423 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
57424 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
57425 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
57426 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
57427 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
57428 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
57429 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
57430 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
57431 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
57432 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
57433 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
57434 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
57435 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
57436 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
57437 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
57438 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
57439 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
57440 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
57441 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
57442 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
57443 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
57444 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
57445 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
57446 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
57447 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
57448 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
57449 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
57450 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
57451 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
57452 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
57453 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
57454 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57455 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57456 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57457 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57458 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57459 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57460 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57461 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57462 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57463 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57464 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57465 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57466 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57467 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57468 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57469 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57470 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57471 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57472 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57473 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57474 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57475 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57476 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57477 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57478 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57479 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57480 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57481 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57482 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57483 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57484 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57485 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57486 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57487 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57488 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57489 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57490 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57491 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57492 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57493 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57494 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57495 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57496 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57497 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57498 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57499 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57500 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57501 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57502 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57503 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57504 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57505 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57506 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57507 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57508 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57509 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57510 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57511 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57512 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57513 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57514 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57515 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57516 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57517 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57518 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57519 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57520 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57521 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57522 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57523 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57524 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57525 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57526 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57527 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57528 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57529 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57530 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57531 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57532 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57533 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57534 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57535 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57536 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57537 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57538 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57539 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57540 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57541 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57542 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57543 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57544 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57545 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57546 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57547 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57548 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57549 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57550 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57551 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57552 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57553 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57554 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57555 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57556 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57557 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57558 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57559 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57560 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57561 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57562 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57563 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57564 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57565 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57566 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57567 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57568 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57569 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57570 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57571 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57572 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57573 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57574 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57575 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57576 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57577 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57578 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57579 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57580 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57581 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57582 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57583 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57584 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57585 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57586 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57587 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57588 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57589 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57590 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57591 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57592 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57593 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57594 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57595 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57596 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57597 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57598 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57599 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57600 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57601 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57602 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57603 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57604 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57605 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57606 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57607 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57608 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57609 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57610 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57611 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57612 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57613 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57614 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57615 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57616 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57617 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57618 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57619 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57620 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57621 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57622 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57623 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57624 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57625 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57626 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57627 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57628 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57629 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57630 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57631 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57632 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57633 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57634 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57635 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57636 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57637 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57638 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57639 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57640 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57641 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57642 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57643 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57644 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57645 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57646 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57647 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57648 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57649 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57650 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57651 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57652 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57653 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57654 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57655 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57656 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57657 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57658 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57659 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57660 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57661 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57662 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57663 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57664 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57665 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57666 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57667 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57668 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57669 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57670 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57671 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57672 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57673 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57674 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57675 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57676 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57677 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57678 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57679 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57680 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57681 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57682 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57683 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57684 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57685 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57686 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57687 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57688 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57689 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57690 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57691 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57692 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57693 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57694 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57695 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57696 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57697 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57698 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57699 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57700 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57701 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57702 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57703 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57704 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57705 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57706 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57707 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57708 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57709 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57710 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57711 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57712 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57713 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57714 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57715 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57716 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57717 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57718 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57719 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57720 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57721 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57722 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57723 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57724 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57725 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57726 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57727 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57728 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57729 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57730 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57731 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57732 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57733 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57734 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57735 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57736 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57737 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57738 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57739 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57740 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57741 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57742 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57743 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57744 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57745 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57746 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57747 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57748 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57749 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57750 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57751 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57752 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57753 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57754 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57755 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57756 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57757 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57758 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57759 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57760 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57761 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57762 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57785 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57786 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57787 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57788 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57789 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57790 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57791 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57792 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57793 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57794 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57795 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57796 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57797 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57798 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57799 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57800 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57801 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57802 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57803 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57804 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57805 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57806 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57807 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57808 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57809 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57810 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57811 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57812 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57813 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57814 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57815 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57816 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57817 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57818 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57819 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57820 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57821 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57822 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57823 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57824 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57825 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57826 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57827 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57828 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57829 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57830 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57831 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57832 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57833 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57834 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57835 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57836 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57837 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57838 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57839 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57840 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57841 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57842 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57843 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57844 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57845 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57846 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57847 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57848 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57849 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57850 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57851 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57852 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57853 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57854 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57855 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57856 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57857 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57858 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57859 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57860 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57861 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57862 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57863 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57864 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57865 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57866 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57867 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57868 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57869 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57870 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57871 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57872 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57873 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57874 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57875 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57876 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57877 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57878 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57879 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57880 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57881 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57882 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57883 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57884 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57885 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57886 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57887 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57888 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57889 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57890 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57891 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57892 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57893 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57894 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57895 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57896 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57897 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57898 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57899 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57900 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57901 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57902 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57903 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57904 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57905 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57906 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57907 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57908 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57909 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57910 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57911 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57912 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57913 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57914 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57915 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57916 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57917 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57918 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57919 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57920 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57921 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57922 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57923 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57924 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57925 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57926 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57927 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57928 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57929 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57930 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57931 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57932 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57933 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57934 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57935 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57936 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57937 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57938 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57939 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57942 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57943 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57944 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57945 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57946 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57947 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57948 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57949 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57950 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57951 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57952 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57953 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57954 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57955 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57956 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57957 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57958 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57959 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57960 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57961 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57962 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57963 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57964 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57965 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57966 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57967 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57968 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57969 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57970 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57971 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57982 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57983 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57984 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57985 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57986 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57987 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57988 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57989 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57990 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57991 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57992 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57993 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57994 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57995 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57996 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57997 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57998 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57999 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
58000 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
58001 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
58002 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
58003 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
58004 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
58005 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
58006 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
58007 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
58008 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
58009 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
58010 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
58011 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
58012 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
58013 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
58014 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
58015 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
58016 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
58017 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
58018 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
58019 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
58020 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
58021 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
58022 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
58023 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
58024 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
58025 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
58026 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
58027 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
58028
58029 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
58030
58031
58032 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
58033
58034 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
58035 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
58036 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
58037 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
58038 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
58039 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
58040 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
58041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
58042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
58043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
58044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
58045 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
58046 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
58047 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
58048 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
58049 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
58050 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
58051 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
58052 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
58053 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
58054 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
58055 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
58056 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
58057 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
58058 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
58059 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
58060 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
58061 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
58062 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
58063 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
58064 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
58065 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
58066 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
58067 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
58068 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
58069 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
58070 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
58071 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
58072 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
58073 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
58074 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
58075 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
58076 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
58077 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
58078 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
58079 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
58080 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
58081 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
58082 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
58083 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
58084 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
58085 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
58086 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
58087 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
58088 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
58089 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
58090 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
58091 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
58092 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
58093 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
58094 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
58095 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
58096 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
58097 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
58098 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
58099 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
58100 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
58101 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
58102 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
58103 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
58104 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
58105 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
58106 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
58107 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
58108 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
58109 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
58110 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
58111 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
58112 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
58113 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
58114 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
58115 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
58116 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
58117 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
58118 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
58119 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
58120 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
58121 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
58122 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
58123 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
58124 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
58125 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
58126 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
58127 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
58128 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
58129 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
58130 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
58131 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
58132 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
58133 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
58134 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
58135 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
58136 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
58137 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
58138 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
58139 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
58140 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
58141 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
58142 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
58143 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
58144 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
58145 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
58146 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
58147 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
58148 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
58149 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
58150 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
58151 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
58152 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
58153 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
58154 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
58155 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
58156 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
58157 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
58158 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
58159 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
58160 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
58161 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
58162 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
58163 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
58164 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
58165 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
58166 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
58167 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
58168 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
58169 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
58170 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
58171 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
58172 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
58173 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
58174 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
58175 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
58176 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
58177 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
58178 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
58179 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
58180 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
58181 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
58182 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
58183 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
58184 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
58185 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
58186 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
58187 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
58188 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
58189 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
58190 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
58191 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
58192 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
58193 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
58194 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
58195 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
58196 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
58197 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
58198 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
58199 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
58200 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
58201 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
58202 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
58203 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
58204 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
58205 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
58206 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
58207 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
58208 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
58209 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
58210 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
58211 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
58212 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
58213 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
58214 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
58215 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
58216 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
58217 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
58218 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
58219 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
58220 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
58221 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
58222 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
58223 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
58224 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
58225 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
58226 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
58227 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
58228 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
58229 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
58230 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
58231 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
58232 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
58233 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
58234 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
58235 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
58236 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
58237 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
58238 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
58239 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
58240 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
58241 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
58242 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
58243 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
58244 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
58245 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
58246 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
58247 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
58248
58249 // Initialize threading, some globals and such
58250 __wxPyPreStart(d);
58251
58252
58253 // Although these are defined in __version__ they need to be here too so
58254 // that an assert can be done to ensure that the wxPython and the wxWindows
58255 // versions match.
58256 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
58257 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
58258 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
58259
58260 }
58261
wxWidgets (Impactor)