]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Missing exports.
[wxWidgets.git] / wxPython / src / mac / _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 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 typedef unsigned char* buffer;
3487
3488
3489 // Pull the nested class out to the top level for SWIG's sake
3490 #define wxImage_RGBValue wxImage::RGBValue
3491 #define wxImage_HSVValue wxImage::HSVValue
3492
3493 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3494 if (width > 0 && height > 0)
3495 return new wxImage(width, height, clear);
3496 else
3497 return new wxImage;
3498 }
3499 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3500 return new wxImage(bitmap.ConvertToImage());
3501 }
3502 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3503 if (DATASIZE != width*height*3) {
3504 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3505 return NULL;
3506 }
3507
3508 // Copy the source data so the wxImage can clean it up later
3509 buffer copy = (buffer)malloc(DATASIZE);
3510 if (copy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(copy, data, DATASIZE);
3515 return new wxImage(width, height, copy, false);
3516 }
3517 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3518 if (DATASIZE != width*height*3) {
3519 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3520 return NULL;
3521 }
3522 if (ALPHASIZE != width*height) {
3523 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3524 return NULL;
3525 }
3526
3527 // Copy the source data so the wxImage can clean it up later
3528 buffer dcopy = (buffer)malloc(DATASIZE);
3529 if (dcopy == NULL) {
3530 wxPyBLOCK_THREADS(PyErr_NoMemory());
3531 return NULL;
3532 }
3533 memcpy(dcopy, data, DATASIZE);
3534
3535 buffer acopy = (buffer)malloc(ALPHASIZE);
3536 if (acopy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return NULL;
3539 }
3540 memcpy(acopy, alpha, ALPHASIZE);
3541
3542 return new wxImage(width, height, dcopy, acopy, false);
3543 }
3544 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3545 wxSize size(self->GetWidth(), self->GetHeight());
3546 return size;
3547 }
3548 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3549 buffer data = self->GetData();
3550 int len = self->GetWidth() * self->GetHeight() * 3;
3551 PyObject* rv;
3552 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3553 return rv;
3554 }
3555 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3556 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return;
3559 }
3560 buffer copy = (buffer)malloc(DATASIZE);
3561 if (copy == NULL) {
3562 wxPyBLOCK_THREADS(PyErr_NoMemory());
3563 return;
3564 }
3565 memcpy(copy, data, DATASIZE);
3566 self->SetData(copy, false);
3567 // wxImage takes ownership of copy...
3568 }
3569 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3570 buffer data = self->GetData();
3571 int len = self->GetWidth() * self->GetHeight() * 3;
3572 PyObject* rv;
3573 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3574 return rv;
3575 }
3576 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3577 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3578 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3579 return;
3580 }
3581 self->SetData(data, true);
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 if (! data) {
3586 RETURN_NONE();
3587 } else {
3588 int len = self->GetWidth() * self->GetHeight();
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3591 return rv;
3592 }
3593 }
3594 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3595 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3597 return;
3598 }
3599 buffer acopy = (buffer)malloc(ALPHASIZE);
3600 if (acopy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(acopy, alpha, ALPHASIZE);
3605 self->SetAlpha(acopy, false);
3606 // wxImage takes ownership of acopy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3609 buffer data = self->GetAlpha();
3610 int len = self->GetWidth() * self->GetHeight();
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3616 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3618 return;
3619 }
3620 self->SetAlpha(alpha, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetHandlers(){
3623 wxList& list = wxImage::GetHandlers();
3624 return wxPy_ConvertList(&list);
3625 }
3626 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3627 wxBitmap bitmap(*self, depth);
3628 return bitmap;
3629 }
3630 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3631 wxImage mono = self->ConvertToMono( red, green, blue );
3632 wxBitmap bitmap( mono, 1 );
3633 return bitmap;
3634 }
3635 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3636 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3638 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3642 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3643 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3644 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3645 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3646 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3647 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3648 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3649 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3650
3651 #include <wx/quantize.h>
3652
3653 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3654 return wxQuantize::Quantize(src, dest,
3655 //NULL, // palette
3656 desiredNoColours,
3657 NULL, // eightBitData
3658 flags);
3659 }
3660 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3661 if (PyCallable_Check(func)) {
3662 self->Connect(id, lastId, eventType,
3663 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3664 new wxPyCallback(func));
3665 }
3666 else if (func == Py_None) {
3667 self->Disconnect(id, lastId, eventType,
3668 (wxObjectEventFunction)
3669 &wxPyCallback::EventThunker);
3670 }
3671 else {
3672 wxPyBLOCK_THREADS(
3673 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3674 }
3675 }
3676 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3677 return self->Disconnect(id, lastId, eventType,
3678 (wxObjectEventFunction)
3679 &wxPyCallback::EventThunker);
3680 }
3681 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3682 if (_self && _self != Py_None) {
3683 self->SetClientObject(new wxPyOORClientData(_self, incref));
3684 }
3685 else {
3686 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3687 if (data) {
3688 self->SetClientObject(NULL); // This will delete it too
3689 }
3690 }
3691 }
3692
3693 #if ! wxUSE_HOTKEY
3694 #define wxEVT_HOTKEY -9999
3695 #endif
3696
3697 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3698 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3699 if (data) {
3700 Py_INCREF(data->m_obj);
3701 return data->m_obj;
3702 } else {
3703 Py_INCREF(Py_None);
3704 return Py_None;
3705 }
3706 }
3707 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3708 wxPyClientData* data = new wxPyClientData(clientData);
3709 self->SetClientObject(data);
3710 }
3711 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3712 #if wxUSE_UNICODE
3713 return self->GetUnicodeKey();
3714 #else
3715 return 0;
3716 #endif
3717 }
3718 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3719 #if wxUSE_UNICODE
3720 self->m_uniChar = uniChar;
3721 #endif
3722 }
3723
3724 SWIGINTERNINLINE PyObject *
3725 SWIG_From_unsigned_SS_int (unsigned int value)
3726 {
3727 return SWIG_From_unsigned_SS_long (value);
3728 }
3729
3730
3731 SWIGINTERN int
3732 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3733 {
3734 unsigned long v;
3735 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3736 if (SWIG_IsOK(res)) {
3737 if ((v > UINT_MAX)) {
3738 return SWIG_OverflowError;
3739 } else {
3740 if (val) *val = static_cast< unsigned int >(v);
3741 }
3742 }
3743 return res;
3744 }
3745
3746 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3747 self->m_size = size;
3748 }
3749 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3750 int count = self->GetNumberOfFiles();
3751 wxString* files = self->GetFiles();
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 PyObject* list = PyList_New(count);
3754
3755 if (!list) {
3756 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3757 wxPyEndBlockThreads(blocked);
3758 return NULL;
3759 }
3760
3761 for (int i=0; i<count; i++) {
3762 PyList_SetItem(list, i, wx2PyString(files[i]));
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return list;
3766 }
3767
3768
3769 SWIGINTERN wxPyApp *new_wxPyApp(){
3770 wxPythonApp = new wxPyApp();
3771 return wxPythonApp;
3772 }
3773 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3774
3775 void wxApp_CleanUp() {
3776 __wxPyCleanup();
3777 }
3778
3779
3780 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3781
3782
3783
3784
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_FromCharPtr(const char *cptr)
3788 {
3789 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3790 }
3791
3792
3793 #if 0 // #ifdef __WXMAC__
3794
3795 // A dummy class that raises an exception if used...
3796 class wxEventLoop
3797 {
3798 public:
3799 wxEventLoop() { wxPyRaiseNotImplemented(); }
3800 int Run() { return 0; }
3801 void Exit(int rc = 0) {}
3802 bool Pending() const { return false; }
3803 bool Dispatch() { return false; }
3804 bool IsRunning() const { return false; }
3805 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3806 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3807 };
3808
3809 #else
3810
3811 #include <wx/evtloop.h>
3812
3813 #endif
3814
3815
3816
3817 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3818 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3819 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3820 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3821 wxWindowList& list = self->GetChildren();
3822 return wxPy_ConvertList(&list);
3823 }
3824 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3825 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3826 #if wxUSE_HOTKEY
3827 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3828 #else
3829 return false;
3830 #endif
3831 }
3832 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3833
3834
3835
3836 return false;
3837
3838 }
3839 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3840 return wxPyGetWinHandle(self);
3841 }
3842 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3843 self->AssociateHandle((WXWidget)handle);
3844 }
3845 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3846
3847 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3848 return wxWindow::FindWindowById(id, parent);
3849 }
3850
3851 wxWindow* wxFindWindowByName( const wxString& name,
3852 const wxWindow *parent = NULL ) {
3853 return wxWindow::FindWindowByName(name, parent);
3854 }
3855
3856 wxWindow* wxFindWindowByLabel( const wxString& label,
3857 const wxWindow *parent = NULL ) {
3858 return wxWindow::FindWindowByLabel(label, parent);
3859 }
3860
3861
3862 #ifdef __WXMSW__
3863 #include <wx/msw/private.h> // to get wxGetWindowId
3864 #endif
3865
3866
3867 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3868 #ifdef __WXMSW__
3869 WXHWND hWnd = (WXHWND)_hWnd;
3870 long id = wxGetWindowId(hWnd);
3871 wxWindow* win = new wxWindow;
3872 if (parent)
3873 parent->AddChild(win);
3874 win->SetEventHandler(win);
3875 win->SetHWND(hWnd);
3876 win->SetId(id);
3877 win->SubclassWin(hWnd);
3878 win->AdoptAttributesFromHWND();
3879 win->SetupColours();
3880 return win;
3881 #else
3882 wxPyRaiseNotImplemented();
3883 return NULL;
3884 #endif
3885 }
3886
3887
3888 PyObject* GetTopLevelWindows() {
3889 return wxPy_ConvertList(&wxTopLevelWindows);
3890 }
3891
3892
3893 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3894 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3895 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3896
3897 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3898
3899
3900 SWIGINTERNINLINE int
3901 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3902 {
3903 unsigned long v;
3904 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3905 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3906 return res;
3907 }
3908
3909 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3910 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3911 wxMenuItemList& list = self->GetMenuItems();
3912 return wxPy_ConvertList(&list);
3913 }
3914 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3915 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3916 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3917 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3918 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3919 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3920 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3921 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3922 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3923 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3924 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3925 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3926 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3927 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3928 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3929 static const wxString wxPyControlNameStr(wxControlNameStr);
3930 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3931 if (clientData) {
3932 wxPyClientData* data = new wxPyClientData(clientData);
3933 return self->Append(item, data);
3934 } else
3935 return self->Append(item);
3936 }
3937 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3938 if (clientData) {
3939 wxPyClientData* data = new wxPyClientData(clientData);
3940 return self->Insert(item, pos, data);
3941 } else
3942 return self->Insert(item, pos);
3943 }
3944 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3945 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3946 if (data) {
3947 Py_INCREF(data->m_obj);
3948 return data->m_obj;
3949 } else {
3950 Py_INCREF(Py_None);
3951 return Py_None;
3952 }
3953 }
3954 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3955 wxPyClientData* data = new wxPyClientData(clientData);
3956 self->SetClientObject(n, data);
3957 }
3958
3959
3960 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3961 wxPyUserData* data = NULL;
3962 if ( userData ) {
3963 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3964 data = new wxPyUserData(userData);
3965 wxPyEndBlockThreads(blocked);
3966 }
3967 return new wxSizerItem(window, proportion, flag, border, data);
3968 }
3969 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3970 wxPyUserData* data = NULL;
3971 if ( userData ) {
3972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3973 data = new wxPyUserData(userData);
3974 wxPyEndBlockThreads(blocked);
3975 }
3976 return new wxSizerItem(width, height, proportion, flag, border, data);
3977 }
3978 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3979 wxPyUserData* data = NULL;
3980 if ( userData ) {
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 data = new wxPyUserData(userData);
3983 wxPyEndBlockThreads(blocked);
3984 }
3985 return new wxSizerItem(sizer, proportion, flag, border, data);
3986 }
3987
3988 SWIGINTERNINLINE PyObject *
3989 SWIG_From_float (float value)
3990 {
3991 return SWIG_From_double (value);
3992 }
3993
3994 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3995 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3996 if (data) {
3997 Py_INCREF(data->m_obj);
3998 return data->m_obj;
3999 } else {
4000 Py_INCREF(Py_None);
4001 return Py_None;
4002 }
4003 }
4004 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 self->SetUserData(data);
4012 }
4013
4014 // Figure out the type of the sizer item
4015
4016 struct wxPySizerItemInfo {
4017 wxPySizerItemInfo()
4018 : window(NULL), sizer(NULL), gotSize(false),
4019 size(wxDefaultSize), gotPos(false), pos(-1)
4020 {}
4021
4022 wxWindow* window;
4023 wxSizer* sizer;
4024 bool gotSize;
4025 wxSize size;
4026 bool gotPos;
4027 int pos;
4028 };
4029
4030 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4031
4032 wxPySizerItemInfo info;
4033 wxSize size;
4034 wxSize* sizePtr = &size;
4035
4036 // Find out what the type of the item is
4037 // try wxWindow
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4039 PyErr_Clear();
4040 info.window = NULL;
4041
4042 // try wxSizer
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4044 PyErr_Clear();
4045 info.sizer = NULL;
4046
4047 // try wxSize or (w,h)
4048 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4049 info.size = *sizePtr;
4050 info.gotSize = true;
4051 }
4052
4053 // or a single int
4054 if (checkIdx && PyInt_Check(item)) {
4055 info.pos = PyInt_AsLong(item);
4056 info.gotPos = true;
4057 }
4058 }
4059 }
4060
4061 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4062 // no expected type, figure out what kind of error message to generate
4063 if ( !checkSize && !checkIdx )
4064 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4065 else if ( checkSize && !checkIdx )
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4067 else if ( !checkSize && checkIdx)
4068 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4069 else
4070 // can this one happen?
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4072 }
4073
4074 return info;
4075 }
4076
4077 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4078 if (!self->GetClientObject())
4079 self->SetClientObject(new wxPyOORClientData(_self));
4080 }
4081 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4082
4083 wxPyUserData* data = NULL;
4084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4086 if ( userData && (info.window || info.sizer || info.gotSize) )
4087 data = new wxPyUserData(userData);
4088 if ( info.sizer )
4089 PyObject_SetAttrString(item,"thisown",Py_False);
4090 wxPyEndBlockThreads(blocked);
4091
4092 // Now call the real Add method if a valid item type was found
4093 if ( info.window )
4094 return self->Add(info.window, proportion, flag, border, data);
4095 else if ( info.sizer )
4096 return self->Add(info.sizer, proportion, flag, border, data);
4097 else if (info.gotSize)
4098 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4099 proportion, flag, border, data);
4100 else
4101 return NULL;
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,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 Insert method if a valid item type was found
4115 if ( info.window )
4116 return self->Insert(before, info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Insert(before, info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,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 Prepend method if a valid item type was found
4137 if ( info.window )
4138 return self->Prepend(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Prepend(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4150 wxPyEndBlockThreads(blocked);
4151 if ( info.window )
4152 return self->Remove(info.window);
4153 else if ( info.sizer )
4154 return self->Remove(info.sizer);
4155 else if ( info.gotPos )
4156 return self->Remove(info.pos);
4157 else
4158 return false;
4159 }
4160 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4163 wxPyEndBlockThreads(blocked);
4164 if ( info.window )
4165 return self->Detach(info.window);
4166 else if ( info.sizer )
4167 return self->Detach(info.sizer);
4168 else if ( info.gotPos )
4169 return self->Detach(info.pos);
4170 else
4171 return false;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4176 wxPyEndBlockThreads(blocked);
4177 if ( info.window )
4178 return self->GetItem(info.window);
4179 else if ( info.sizer )
4180 return self->GetItem(info.sizer);
4181 else if ( info.gotPos )
4182 return self->GetItem(info.pos);
4183 else
4184 return NULL;
4185 }
4186 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 self->SetItemMinSize(info.window, size);
4192 else if ( info.sizer )
4193 self->SetItemMinSize(info.sizer, size);
4194 else if ( info.gotPos )
4195 self->SetItemMinSize(info.pos, size);
4196 }
4197 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4198 wxSizerItemList& list = self->GetChildren();
4199 return wxPy_ConvertList(&list);
4200 }
4201 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4204 wxPyEndBlockThreads(blocked);
4205 if ( info.window )
4206 return self->Show(info.window, show, recursive);
4207 else if ( info.sizer )
4208 return self->Show(info.sizer, show, recursive);
4209 else if ( info.gotPos )
4210 return self->Show(info.pos, show);
4211 else
4212 return false;
4213 }
4214 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4216 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4217 wxPyEndBlockThreads(blocked);
4218 if ( info.window )
4219 return self->IsShown(info.window);
4220 else if ( info.sizer )
4221 return self->IsShown(info.sizer);
4222 else if ( info.gotPos )
4223 return self->IsShown(info.pos);
4224 else
4225 return false;
4226 }
4227
4228 // See pyclasses.h
4229 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4230 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4231 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4232
4233
4234
4235
4236 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4237 {
4238 if (source == Py_None) {
4239 **obj = wxGBPosition(-1,-1);
4240 return true;
4241 }
4242 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4243 }
4244
4245 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4246 {
4247 if (source == Py_None) {
4248 **obj = wxGBSpan(-1,-1);
4249 return true;
4250 }
4251 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4252 }
4253
4254
4255 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4256 wxGBPosition temp, *obj = &temp;
4257 if ( other == Py_None ) return false;
4258 if ( ! wxGBPosition_helper(other, &obj) ) {
4259 PyErr_Clear();
4260 return false;
4261 }
4262 return self->operator==(*obj);
4263 }
4264 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4265 wxGBPosition temp, *obj = &temp;
4266 if ( other == Py_None ) return true;
4267 if ( ! wxGBPosition_helper(other, &obj)) {
4268 PyErr_Clear();
4269 return true;
4270 }
4271 return self->operator!=(*obj);
4272 }
4273 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4274 self->SetRow(row);
4275 self->SetCol(col);
4276 }
4277 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 PyObject* tup = PyTuple_New(2);
4280 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4281 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4282 wxPyEndBlockThreads(blocked);
4283 return tup;
4284 }
4285 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4286 wxGBSpan temp, *obj = &temp;
4287 if ( other == Py_None ) return false;
4288 if ( ! wxGBSpan_helper(other, &obj) ) {
4289 PyErr_Clear();
4290 return false;
4291 }
4292 return self->operator==(*obj);
4293 }
4294 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4295 wxGBSpan temp, *obj = &temp;
4296 if ( other == Py_None ) return true;
4297 if ( ! wxGBSpan_helper(other, &obj)) {
4298 PyErr_Clear();
4299 return true;
4300 }
4301 return self->operator!=(*obj);
4302 }
4303 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4304 self->SetRowspan(rowspan);
4305 self->SetColspan(colspan);
4306 }
4307 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 PyObject* tup = PyTuple_New(2);
4310 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4311 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4312 wxPyEndBlockThreads(blocked);
4313 return tup;
4314 }
4315 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4316 wxPyUserData* data = NULL;
4317 if ( userData ) {
4318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4319 data = new wxPyUserData(userData);
4320 wxPyEndBlockThreads(blocked);
4321 }
4322 return new wxGBSizerItem(window, pos, span, flag, border, data);
4323 }
4324 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4325 wxPyUserData* data = NULL;
4326 if ( userData ) {
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 data = new wxPyUserData(userData);
4329 wxPyEndBlockThreads(blocked);
4330 }
4331 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4332 }
4333 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4334 wxPyUserData* data = NULL;
4335 if ( userData ) {
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 data = new wxPyUserData(userData);
4338 wxPyEndBlockThreads(blocked);
4339 }
4340 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4341 }
4342 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4343 int row, col;
4344 self->GetEndPos(row, col);
4345 return wxGBPosition(row, col);
4346 }
4347 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4348
4349 wxPyUserData* data = NULL;
4350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4351 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4352 if ( userData && (info.window || info.sizer || info.gotSize) )
4353 data = new wxPyUserData(userData);
4354 if ( info.sizer )
4355 PyObject_SetAttrString(item,"thisown",Py_False);
4356 wxPyEndBlockThreads(blocked);
4357
4358 // Now call the real Add method if a valid item type was found
4359 if ( info.window )
4360 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4361 else if ( info.sizer )
4362 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4363 else if (info.gotSize)
4364 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4365 pos, span, flag, border, data);
4366 return NULL;
4367 }
4368
4369
4370 #ifdef __cplusplus
4371 extern "C" {
4372 #endif
4373 SWIGINTERN int EmptyString_set(PyObject *) {
4374 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4375 return 1;
4376 }
4377
4378
4379 SWIGINTERN PyObject *EmptyString_get(void) {
4380 PyObject *pyobj = 0;
4381
4382 {
4383 #if wxUSE_UNICODE
4384 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4385 #else
4386 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4387 #endif
4388 }
4389 return pyobj;
4390 }
4391
4392
4393 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4394 PyObject *resultobj = 0;
4395 wxObject *arg1 = (wxObject *) 0 ;
4396 wxString result;
4397 void *argp1 = 0 ;
4398 int res1 = 0 ;
4399 PyObject *swig_obj[1] ;
4400
4401 if (!args) SWIG_fail;
4402 swig_obj[0] = args;
4403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4404 if (!SWIG_IsOK(res1)) {
4405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4406 }
4407 arg1 = reinterpret_cast< wxObject * >(argp1);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxObject_GetClassName(arg1);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 {
4415 #if wxUSE_UNICODE
4416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4417 #else
4418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4419 #endif
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428 PyObject *resultobj = 0;
4429 wxObject *arg1 = (wxObject *) 0 ;
4430 void *argp1 = 0 ;
4431 int res1 = 0 ;
4432 PyObject *swig_obj[1] ;
4433
4434 if (!args) SWIG_fail;
4435 swig_obj[0] = args;
4436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4437 if (!SWIG_IsOK(res1)) {
4438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4439 }
4440 arg1 = reinterpret_cast< wxObject * >(argp1);
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxObject_Destroy(arg1);
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 resultobj = SWIG_Py_Void();
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4455 PyObject *obj;
4456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4457 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4458 return SWIG_Py_Void();
4459 }
4460
4461 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 wxSize *arg1 = (wxSize *) 0 ;
4464 int arg2 ;
4465 void *argp1 = 0 ;
4466 int res1 = 0 ;
4467 int val2 ;
4468 int ecode2 = 0 ;
4469 PyObject *swig_obj[2] ;
4470
4471 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4478 if (!SWIG_IsOK(ecode2)) {
4479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4480 }
4481 arg2 = static_cast< int >(val2);
4482 if (arg1) (arg1)->x = arg2;
4483
4484 resultobj = SWIG_Py_Void();
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxSize *arg1 = (wxSize *) 0 ;
4494 int result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4504 }
4505 arg1 = reinterpret_cast< wxSize * >(argp1);
4506 result = (int) ((arg1)->x);
4507 resultobj = SWIG_From_int(static_cast< int >(result));
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 PyObject *resultobj = 0;
4516 wxSize *arg1 = (wxSize *) 0 ;
4517 int arg2 ;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 int val2 ;
4521 int ecode2 = 0 ;
4522 PyObject *swig_obj[2] ;
4523
4524 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4531 if (!SWIG_IsOK(ecode2)) {
4532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4533 }
4534 arg2 = static_cast< int >(val2);
4535 if (arg1) (arg1)->y = arg2;
4536
4537 resultobj = SWIG_Py_Void();
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4545 PyObject *resultobj = 0;
4546 wxSize *arg1 = (wxSize *) 0 ;
4547 int result;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550 PyObject *swig_obj[1] ;
4551
4552 if (!args) SWIG_fail;
4553 swig_obj[0] = args;
4554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 result = (int) ((arg1)->y);
4560 resultobj = SWIG_From_int(static_cast< int >(result));
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = 0;
4569 int arg1 = (int) 0 ;
4570 int arg2 = (int) 0 ;
4571 wxSize *result = 0 ;
4572 int val1 ;
4573 int ecode1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char * kwnames[] = {
4579 (char *) "w",(char *) "h", NULL
4580 };
4581
4582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4583 if (obj0) {
4584 ecode1 = SWIG_AsVal_int(obj0, &val1);
4585 if (!SWIG_IsOK(ecode1)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4587 }
4588 arg1 = static_cast< int >(val1);
4589 }
4590 if (obj1) {
4591 ecode2 = SWIG_AsVal_int(obj1, &val2);
4592 if (!SWIG_IsOK(ecode2)) {
4593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4594 }
4595 arg2 = static_cast< int >(val2);
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (wxSize *)new wxSize(arg1,arg2);
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4604 return resultobj;
4605 fail:
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4611 PyObject *resultobj = 0;
4612 wxSize *arg1 = (wxSize *) 0 ;
4613 void *argp1 = 0 ;
4614 int res1 = 0 ;
4615 PyObject *swig_obj[1] ;
4616
4617 if (!args) SWIG_fail;
4618 swig_obj[0] = args;
4619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4620 if (!SWIG_IsOK(res1)) {
4621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4622 }
4623 arg1 = reinterpret_cast< wxSize * >(argp1);
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 delete arg1;
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxSize *arg1 = (wxSize *) 0 ;
4641 PyObject *arg2 = (PyObject *) 0 ;
4642 bool result;
4643 void *argp1 = 0 ;
4644 int res1 = 0 ;
4645 PyObject * obj0 = 0 ;
4646 PyObject * obj1 = 0 ;
4647 char * kwnames[] = {
4648 (char *) "self",(char *) "other", NULL
4649 };
4650
4651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4653 if (!SWIG_IsOK(res1)) {
4654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4655 }
4656 arg1 = reinterpret_cast< wxSize * >(argp1);
4657 arg2 = obj1;
4658 {
4659 result = (bool)wxSize___eq__(arg1,arg2);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 {
4663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4664 }
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 PyObject *arg2 = (PyObject *) 0 ;
4675 bool result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "other", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 arg2 = obj1;
4691 {
4692 result = (bool)wxSize___ne__(arg1,arg2);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 {
4696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4697 }
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = 0;
4706 wxSize *arg1 = (wxSize *) 0 ;
4707 wxSize *arg2 = 0 ;
4708 wxSize result;
4709 void *argp1 = 0 ;
4710 int res1 = 0 ;
4711 wxSize temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "self",(char *) "sz", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4720 if (!SWIG_IsOK(res1)) {
4721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4722 }
4723 arg1 = reinterpret_cast< wxSize * >(argp1);
4724 {
4725 arg2 = &temp2;
4726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (arg1)->operator +((wxSize const &)*arg2);
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 wxSize *arg2 = 0 ;
4745 wxSize result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 wxSize temp2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "sz", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 {
4762 arg2 = &temp2;
4763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (arg1)->operator -((wxSize const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj = 0;
4780 wxSize *arg1 = (wxSize *) 0 ;
4781 wxSize *arg2 = 0 ;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 wxSize temp2 ;
4785 PyObject * obj0 = 0 ;
4786 PyObject * obj1 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "sz", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4795 }
4796 arg1 = reinterpret_cast< wxSize * >(argp1);
4797 {
4798 arg2 = &temp2;
4799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->IncTo((wxSize const &)*arg2);
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_Py_Void();
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = 0;
4816 wxSize *arg1 = (wxSize *) 0 ;
4817 wxSize *arg2 = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char * kwnames[] = {
4824 (char *) "self",(char *) "sz", NULL
4825 };
4826
4827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4831 }
4832 arg1 = reinterpret_cast< wxSize * >(argp1);
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 (arg1)->DecTo((wxSize const &)*arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 resultobj = SWIG_Py_Void();
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj = 0;
4852 wxSize *arg1 = (wxSize *) 0 ;
4853 float arg2 ;
4854 float arg3 ;
4855 void *argp1 = 0 ;
4856 int res1 = 0 ;
4857 float val2 ;
4858 int ecode2 = 0 ;
4859 float val3 ;
4860 int ecode3 = 0 ;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 PyObject * obj2 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4872 }
4873 arg1 = reinterpret_cast< wxSize * >(argp1);
4874 ecode2 = SWIG_AsVal_float(obj1, &val2);
4875 if (!SWIG_IsOK(ecode2)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4877 }
4878 arg2 = static_cast< float >(val2);
4879 ecode3 = SWIG_AsVal_float(obj2, &val3);
4880 if (!SWIG_IsOK(ecode3)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4882 }
4883 arg3 = static_cast< float >(val3);
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 (arg1)->Scale(arg2,arg3);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_Py_Void();
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = 0;
4899 wxSize *arg1 = (wxSize *) 0 ;
4900 int arg2 ;
4901 int arg3 ;
4902 void *argp1 = 0 ;
4903 int res1 = 0 ;
4904 int val2 ;
4905 int ecode2 = 0 ;
4906 int val3 ;
4907 int ecode3 = 0 ;
4908 PyObject * obj0 = 0 ;
4909 PyObject * obj1 = 0 ;
4910 PyObject * obj2 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "self",(char *) "w",(char *) "h", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4917 if (!SWIG_IsOK(res1)) {
4918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4919 }
4920 arg1 = reinterpret_cast< wxSize * >(argp1);
4921 ecode2 = SWIG_AsVal_int(obj1, &val2);
4922 if (!SWIG_IsOK(ecode2)) {
4923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4924 }
4925 arg2 = static_cast< int >(val2);
4926 ecode3 = SWIG_AsVal_int(obj2, &val3);
4927 if (!SWIG_IsOK(ecode3)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4929 }
4930 arg3 = static_cast< int >(val3);
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 (arg1)->Set(arg2,arg3);
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 resultobj = SWIG_Py_Void();
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj = 0;
4946 wxSize *arg1 = (wxSize *) 0 ;
4947 int arg2 ;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 int val2 ;
4951 int ecode2 = 0 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 char * kwnames[] = {
4955 (char *) "self",(char *) "w", NULL
4956 };
4957
4958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4960 if (!SWIG_IsOK(res1)) {
4961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4962 }
4963 arg1 = reinterpret_cast< wxSize * >(argp1);
4964 ecode2 = SWIG_AsVal_int(obj1, &val2);
4965 if (!SWIG_IsOK(ecode2)) {
4966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4967 }
4968 arg2 = static_cast< int >(val2);
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 (arg1)->SetWidth(arg2);
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 resultobj = SWIG_Py_Void();
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj = 0;
4984 wxSize *arg1 = (wxSize *) 0 ;
4985 int arg2 ;
4986 void *argp1 = 0 ;
4987 int res1 = 0 ;
4988 int val2 ;
4989 int ecode2 = 0 ;
4990 PyObject * obj0 = 0 ;
4991 PyObject * obj1 = 0 ;
4992 char * kwnames[] = {
4993 (char *) "self",(char *) "h", NULL
4994 };
4995
4996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5000 }
5001 arg1 = reinterpret_cast< wxSize * >(argp1);
5002 ecode2 = SWIG_AsVal_int(obj1, &val2);
5003 if (!SWIG_IsOK(ecode2)) {
5004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5005 }
5006 arg2 = static_cast< int >(val2);
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 (arg1)->SetHeight(arg2);
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 int result;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 PyObject *swig_obj[1] ;
5027
5028 if (!args) SWIG_fail;
5029 swig_obj[0] = args;
5030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5031 if (!SWIG_IsOK(res1)) {
5032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5033 }
5034 arg1 = reinterpret_cast< wxSize * >(argp1);
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)((wxSize const *)arg1)->GetWidth();
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 resultobj = SWIG_From_int(static_cast< int >(result));
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5049 PyObject *resultobj = 0;
5050 wxSize *arg1 = (wxSize *) 0 ;
5051 int result;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 PyObject *swig_obj[1] ;
5055
5056 if (!args) SWIG_fail;
5057 swig_obj[0] = args;
5058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5059 if (!SWIG_IsOK(res1)) {
5060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5061 }
5062 arg1 = reinterpret_cast< wxSize * >(argp1);
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (int)((wxSize const *)arg1)->GetHeight();
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_From_int(static_cast< int >(result));
5070 return resultobj;
5071 fail:
5072 return NULL;
5073 }
5074
5075
5076 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5077 PyObject *resultobj = 0;
5078 wxSize *arg1 = (wxSize *) 0 ;
5079 bool result;
5080 void *argp1 = 0 ;
5081 int res1 = 0 ;
5082 PyObject *swig_obj[1] ;
5083
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5089 }
5090 arg1 = reinterpret_cast< wxSize * >(argp1);
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 wxSize *arg1 = (wxSize *) 0 ;
5109 wxSize *arg2 = 0 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 wxSize temp2 ;
5113 PyObject * obj0 = 0 ;
5114 PyObject * obj1 = 0 ;
5115 char * kwnames[] = {
5116 (char *) "self",(char *) "size", NULL
5117 };
5118
5119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5121 if (!SWIG_IsOK(res1)) {
5122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5123 }
5124 arg1 = reinterpret_cast< wxSize * >(argp1);
5125 {
5126 arg2 = &temp2;
5127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5128 }
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 (arg1)->SetDefaults((wxSize const &)*arg2);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5143 PyObject *resultobj = 0;
5144 wxSize *arg1 = (wxSize *) 0 ;
5145 PyObject *result = 0 ;
5146 void *argp1 = 0 ;
5147 int res1 = 0 ;
5148 PyObject *swig_obj[1] ;
5149
5150 if (!args) SWIG_fail;
5151 swig_obj[0] = args;
5152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5153 if (!SWIG_IsOK(res1)) {
5154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5155 }
5156 arg1 = reinterpret_cast< wxSize * >(argp1);
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 result = (PyObject *)wxSize_Get(arg1);
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = result;
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5171 PyObject *obj;
5172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5173 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5174 return SWIG_Py_Void();
5175 }
5176
5177 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 return SWIG_Python_InitShadowInstance(args);
5179 }
5180
5181 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 PyObject *resultobj = 0;
5183 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5184 double arg2 ;
5185 void *argp1 = 0 ;
5186 int res1 = 0 ;
5187 double val2 ;
5188 int ecode2 = 0 ;
5189 PyObject *swig_obj[2] ;
5190
5191 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5195 }
5196 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5197 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5198 if (!SWIG_IsOK(ecode2)) {
5199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5200 }
5201 arg2 = static_cast< double >(val2);
5202 if (arg1) (arg1)->x = arg2;
5203
5204 resultobj = SWIG_Py_Void();
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5212 PyObject *resultobj = 0;
5213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5214 double result;
5215 void *argp1 = 0 ;
5216 int res1 = 0 ;
5217 PyObject *swig_obj[1] ;
5218
5219 if (!args) SWIG_fail;
5220 swig_obj[0] = args;
5221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5222 if (!SWIG_IsOK(res1)) {
5223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5224 }
5225 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5226 result = (double) ((arg1)->x);
5227 resultobj = SWIG_From_double(static_cast< double >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5237 double arg2 ;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 double val2 ;
5241 int ecode2 = 0 ;
5242 PyObject *swig_obj[2] ;
5243
5244 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5246 if (!SWIG_IsOK(res1)) {
5247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5248 }
5249 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5250 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5251 if (!SWIG_IsOK(ecode2)) {
5252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5253 }
5254 arg2 = static_cast< double >(val2);
5255 if (arg1) (arg1)->y = arg2;
5256
5257 resultobj = SWIG_Py_Void();
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265 PyObject *resultobj = 0;
5266 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5267 double result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 PyObject *swig_obj[1] ;
5271
5272 if (!args) SWIG_fail;
5273 swig_obj[0] = args;
5274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5277 }
5278 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5279 result = (double) ((arg1)->y);
5280 resultobj = SWIG_From_double(static_cast< double >(result));
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = 0;
5289 double arg1 = (double) 0.0 ;
5290 double arg2 = (double) 0.0 ;
5291 wxRealPoint *result = 0 ;
5292 double val1 ;
5293 int ecode1 = 0 ;
5294 double val2 ;
5295 int ecode2 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 PyObject * obj1 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "x",(char *) "y", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5303 if (obj0) {
5304 ecode1 = SWIG_AsVal_double(obj0, &val1);
5305 if (!SWIG_IsOK(ecode1)) {
5306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5307 }
5308 arg1 = static_cast< double >(val1);
5309 }
5310 if (obj1) {
5311 ecode2 = SWIG_AsVal_double(obj1, &val2);
5312 if (!SWIG_IsOK(ecode2)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5314 }
5315 arg2 = static_cast< double >(val2);
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5331 PyObject *resultobj = 0;
5332 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject *swig_obj[1] ;
5336
5337 if (!args) SWIG_fail;
5338 swig_obj[0] = args;
5339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5342 }
5343 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 delete arg1;
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 resultobj = SWIG_Py_Void();
5352 return resultobj;
5353 fail:
5354 return NULL;
5355 }
5356
5357
5358 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5359 PyObject *resultobj = 0;
5360 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5361 PyObject *arg2 = (PyObject *) 0 ;
5362 bool result;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char * kwnames[] = {
5368 (char *) "self",(char *) "other", NULL
5369 };
5370
5371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 arg2 = obj1;
5378 {
5379 result = (bool)wxRealPoint___eq__(arg1,arg2);
5380 if (PyErr_Occurred()) SWIG_fail;
5381 }
5382 {
5383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj = 0;
5393 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5394 PyObject *arg2 = (PyObject *) 0 ;
5395 bool result;
5396 void *argp1 = 0 ;
5397 int res1 = 0 ;
5398 PyObject * obj0 = 0 ;
5399 PyObject * obj1 = 0 ;
5400 char * kwnames[] = {
5401 (char *) "self",(char *) "other", NULL
5402 };
5403
5404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5406 if (!SWIG_IsOK(res1)) {
5407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5408 }
5409 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5410 arg2 = obj1;
5411 {
5412 result = (bool)wxRealPoint___ne__(arg1,arg2);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj = 0;
5426 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5427 wxRealPoint *arg2 = 0 ;
5428 wxRealPoint result;
5429 void *argp1 = 0 ;
5430 int res1 = 0 ;
5431 wxRealPoint temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char * kwnames[] = {
5435 (char *) "self",(char *) "pt", NULL
5436 };
5437
5438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 arg2 = &temp2;
5446 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5447 }
5448 {
5449 PyThreadState* __tstate = wxPyBeginAllowThreads();
5450 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5451 wxPyEndAllowThreads(__tstate);
5452 if (PyErr_Occurred()) SWIG_fail;
5453 }
5454 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5462 PyObject *resultobj = 0;
5463 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5464 wxRealPoint *arg2 = 0 ;
5465 wxRealPoint result;
5466 void *argp1 = 0 ;
5467 int res1 = 0 ;
5468 wxRealPoint temp2 ;
5469 PyObject * obj0 = 0 ;
5470 PyObject * obj1 = 0 ;
5471 char * kwnames[] = {
5472 (char *) "self",(char *) "pt", NULL
5473 };
5474
5475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5477 if (!SWIG_IsOK(res1)) {
5478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5479 }
5480 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5481 {
5482 arg2 = &temp2;
5483 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5484 }
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj = 0;
5500 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5501 double arg2 ;
5502 double arg3 ;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 double val2 ;
5506 int ecode2 = 0 ;
5507 double val3 ;
5508 int ecode3 = 0 ;
5509 PyObject * obj0 = 0 ;
5510 PyObject * obj1 = 0 ;
5511 PyObject * obj2 = 0 ;
5512 char * kwnames[] = {
5513 (char *) "self",(char *) "x",(char *) "y", NULL
5514 };
5515
5516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5518 if (!SWIG_IsOK(res1)) {
5519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5520 }
5521 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5522 ecode2 = SWIG_AsVal_double(obj1, &val2);
5523 if (!SWIG_IsOK(ecode2)) {
5524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5525 }
5526 arg2 = static_cast< double >(val2);
5527 ecode3 = SWIG_AsVal_double(obj2, &val3);
5528 if (!SWIG_IsOK(ecode3)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5530 }
5531 arg3 = static_cast< double >(val3);
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 wxRealPoint_Set(arg1,arg2,arg3);
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 resultobj = SWIG_Py_Void();
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5546 PyObject *resultobj = 0;
5547 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5548 PyObject *result = 0 ;
5549 void *argp1 = 0 ;
5550 int res1 = 0 ;
5551 PyObject *swig_obj[1] ;
5552
5553 if (!args) SWIG_fail;
5554 swig_obj[0] = args;
5555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 result = (PyObject *)wxRealPoint_Get(arg1);
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 resultobj = result;
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5574 PyObject *obj;
5575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5576 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5577 return SWIG_Py_Void();
5578 }
5579
5580 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 return SWIG_Python_InitShadowInstance(args);
5582 }
5583
5584 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586 wxPoint *arg1 = (wxPoint *) 0 ;
5587 int arg2 ;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 int val2 ;
5591 int ecode2 = 0 ;
5592 PyObject *swig_obj[2] ;
5593
5594 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5596 if (!SWIG_IsOK(res1)) {
5597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5598 }
5599 arg1 = reinterpret_cast< wxPoint * >(argp1);
5600 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5601 if (!SWIG_IsOK(ecode2)) {
5602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5603 }
5604 arg2 = static_cast< int >(val2);
5605 if (arg1) (arg1)->x = arg2;
5606
5607 resultobj = SWIG_Py_Void();
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5615 PyObject *resultobj = 0;
5616 wxPoint *arg1 = (wxPoint *) 0 ;
5617 int result;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 PyObject *swig_obj[1] ;
5621
5622 if (!args) SWIG_fail;
5623 swig_obj[0] = args;
5624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5625 if (!SWIG_IsOK(res1)) {
5626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5627 }
5628 arg1 = reinterpret_cast< wxPoint * >(argp1);
5629 result = (int) ((arg1)->x);
5630 resultobj = SWIG_From_int(static_cast< int >(result));
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 int arg2 ;
5641 void *argp1 = 0 ;
5642 int res1 = 0 ;
5643 int val2 ;
5644 int ecode2 = 0 ;
5645 PyObject *swig_obj[2] ;
5646
5647 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5649 if (!SWIG_IsOK(res1)) {
5650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5651 }
5652 arg1 = reinterpret_cast< wxPoint * >(argp1);
5653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5654 if (!SWIG_IsOK(ecode2)) {
5655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5656 }
5657 arg2 = static_cast< int >(val2);
5658 if (arg1) (arg1)->y = arg2;
5659
5660 resultobj = SWIG_Py_Void();
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5668 PyObject *resultobj = 0;
5669 wxPoint *arg1 = (wxPoint *) 0 ;
5670 int result;
5671 void *argp1 = 0 ;
5672 int res1 = 0 ;
5673 PyObject *swig_obj[1] ;
5674
5675 if (!args) SWIG_fail;
5676 swig_obj[0] = args;
5677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxPoint * >(argp1);
5682 result = (int) ((arg1)->y);
5683 resultobj = SWIG_From_int(static_cast< int >(result));
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj = 0;
5692 int arg1 = (int) 0 ;
5693 int arg2 = (int) 0 ;
5694 wxPoint *result = 0 ;
5695 int val1 ;
5696 int ecode1 = 0 ;
5697 int val2 ;
5698 int ecode2 = 0 ;
5699 PyObject * obj0 = 0 ;
5700 PyObject * obj1 = 0 ;
5701 char * kwnames[] = {
5702 (char *) "x",(char *) "y", NULL
5703 };
5704
5705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5706 if (obj0) {
5707 ecode1 = SWIG_AsVal_int(obj0, &val1);
5708 if (!SWIG_IsOK(ecode1)) {
5709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5710 }
5711 arg1 = static_cast< int >(val1);
5712 }
5713 if (obj1) {
5714 ecode2 = SWIG_AsVal_int(obj1, &val2);
5715 if (!SWIG_IsOK(ecode2)) {
5716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5717 }
5718 arg2 = static_cast< int >(val2);
5719 }
5720 {
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 result = (wxPoint *)new wxPoint(arg1,arg2);
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5734 PyObject *resultobj = 0;
5735 wxPoint *arg1 = (wxPoint *) 0 ;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 PyObject *swig_obj[1] ;
5739
5740 if (!args) SWIG_fail;
5741 swig_obj[0] = args;
5742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5743 if (!SWIG_IsOK(res1)) {
5744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5745 }
5746 arg1 = reinterpret_cast< wxPoint * >(argp1);
5747 {
5748 PyThreadState* __tstate = wxPyBeginAllowThreads();
5749 delete arg1;
5750
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_Py_Void();
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj = 0;
5763 wxPoint *arg1 = (wxPoint *) 0 ;
5764 PyObject *arg2 = (PyObject *) 0 ;
5765 bool result;
5766 void *argp1 = 0 ;
5767 int res1 = 0 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "self",(char *) "other", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 arg2 = obj1;
5781 {
5782 result = (bool)wxPoint___eq__(arg1,arg2);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 {
5786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5787 }
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj = 0;
5796 wxPoint *arg1 = (wxPoint *) 0 ;
5797 PyObject *arg2 = (PyObject *) 0 ;
5798 bool result;
5799 void *argp1 = 0 ;
5800 int res1 = 0 ;
5801 PyObject * obj0 = 0 ;
5802 PyObject * obj1 = 0 ;
5803 char * kwnames[] = {
5804 (char *) "self",(char *) "other", NULL
5805 };
5806
5807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5809 if (!SWIG_IsOK(res1)) {
5810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5811 }
5812 arg1 = reinterpret_cast< wxPoint * >(argp1);
5813 arg2 = obj1;
5814 {
5815 result = (bool)wxPoint___ne__(arg1,arg2);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 {
5819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5820 }
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = 0;
5829 wxPoint *arg1 = (wxPoint *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint result;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 wxPoint temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char * kwnames[] = {
5838 (char *) "self",(char *) "pt", NULL
5839 };
5840
5841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 arg2 = &temp2;
5849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 result = (arg1)->operator +((wxPoint const &)*arg2);
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj = 0;
5866 wxPoint *arg1 = (wxPoint *) 0 ;
5867 wxPoint *arg2 = 0 ;
5868 wxPoint result;
5869 void *argp1 = 0 ;
5870 int res1 = 0 ;
5871 wxPoint temp2 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char * kwnames[] = {
5875 (char *) "self",(char *) "pt", NULL
5876 };
5877
5878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5880 if (!SWIG_IsOK(res1)) {
5881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5882 }
5883 arg1 = reinterpret_cast< wxPoint * >(argp1);
5884 {
5885 arg2 = &temp2;
5886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5887 }
5888 {
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 result = (arg1)->operator -((wxPoint const &)*arg2);
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = 0;
5903 wxPoint *arg1 = (wxPoint *) 0 ;
5904 wxPoint *arg2 = 0 ;
5905 wxPoint *result = 0 ;
5906 void *argp1 = 0 ;
5907 int res1 = 0 ;
5908 wxPoint temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char * kwnames[] = {
5912 (char *) "self",(char *) "pt", NULL
5913 };
5914
5915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5919 }
5920 arg1 = reinterpret_cast< wxPoint * >(argp1);
5921 {
5922 arg2 = &temp2;
5923 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5924 }
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 {
5928 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5929 result = (wxPoint *) &_result_ref;
5930 }
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxPoint *arg1 = (wxPoint *) 0 ;
5944 wxPoint *arg2 = 0 ;
5945 wxPoint *result = 0 ;
5946 void *argp1 = 0 ;
5947 int res1 = 0 ;
5948 wxPoint temp2 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char * kwnames[] = {
5952 (char *) "self",(char *) "pt", NULL
5953 };
5954
5955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5957 if (!SWIG_IsOK(res1)) {
5958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5959 }
5960 arg1 = reinterpret_cast< wxPoint * >(argp1);
5961 {
5962 arg2 = &temp2;
5963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5964 }
5965 {
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 {
5968 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5969 result = (wxPoint *) &_result_ref;
5970 }
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = (wxPoint *) 0 ;
5984 long arg2 ;
5985 long arg3 ;
5986 void *argp1 = 0 ;
5987 int res1 = 0 ;
5988 long val2 ;
5989 int ecode2 = 0 ;
5990 long val3 ;
5991 int ecode3 = 0 ;
5992 PyObject * obj0 = 0 ;
5993 PyObject * obj1 = 0 ;
5994 PyObject * obj2 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "x",(char *) "y", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 ecode2 = SWIG_AsVal_long(obj1, &val2);
6006 if (!SWIG_IsOK(ecode2)) {
6007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6008 }
6009 arg2 = static_cast< long >(val2);
6010 ecode3 = SWIG_AsVal_long(obj2, &val3);
6011 if (!SWIG_IsOK(ecode3)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6013 }
6014 arg3 = static_cast< long >(val3);
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 wxPoint_Set(arg1,arg2,arg3);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 resultobj = SWIG_Py_Void();
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029 PyObject *resultobj = 0;
6030 wxPoint *arg1 = (wxPoint *) 0 ;
6031 PyObject *result = 0 ;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject *swig_obj[1] ;
6035
6036 if (!args) SWIG_fail;
6037 swig_obj[0] = args;
6038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6039 if (!SWIG_IsOK(res1)) {
6040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6041 }
6042 arg1 = reinterpret_cast< wxPoint * >(argp1);
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (PyObject *)wxPoint_Get(arg1);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = result;
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6057 PyObject *obj;
6058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6060 return SWIG_Py_Void();
6061 }
6062
6063 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6064 return SWIG_Python_InitShadowInstance(args);
6065 }
6066
6067 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj = 0;
6069 int arg1 = (int) 0 ;
6070 int arg2 = (int) 0 ;
6071 int arg3 = (int) 0 ;
6072 int arg4 = (int) 0 ;
6073 wxRect *result = 0 ;
6074 int val1 ;
6075 int ecode1 = 0 ;
6076 int val2 ;
6077 int ecode2 = 0 ;
6078 int val3 ;
6079 int ecode3 = 0 ;
6080 int val4 ;
6081 int ecode4 = 0 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 PyObject * obj3 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6091 if (obj0) {
6092 ecode1 = SWIG_AsVal_int(obj0, &val1);
6093 if (!SWIG_IsOK(ecode1)) {
6094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6095 }
6096 arg1 = static_cast< int >(val1);
6097 }
6098 if (obj1) {
6099 ecode2 = SWIG_AsVal_int(obj1, &val2);
6100 if (!SWIG_IsOK(ecode2)) {
6101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6102 }
6103 arg2 = static_cast< int >(val2);
6104 }
6105 if (obj2) {
6106 ecode3 = SWIG_AsVal_int(obj2, &val3);
6107 if (!SWIG_IsOK(ecode3)) {
6108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6109 }
6110 arg3 = static_cast< int >(val3);
6111 }
6112 if (obj3) {
6113 ecode4 = SWIG_AsVal_int(obj3, &val4);
6114 if (!SWIG_IsOK(ecode4)) {
6115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6116 }
6117 arg4 = static_cast< int >(val4);
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj = 0;
6134 wxPoint *arg1 = 0 ;
6135 wxPoint *arg2 = 0 ;
6136 wxRect *result = 0 ;
6137 wxPoint temp1 ;
6138 wxPoint temp2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char * kwnames[] = {
6142 (char *) "topLeft",(char *) "bottomRight", NULL
6143 };
6144
6145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6146 {
6147 arg1 = &temp1;
6148 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6149 }
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 wxPoint *arg1 = 0 ;
6170 wxSize *arg2 = 0 ;
6171 wxRect *result = 0 ;
6172 wxPoint temp1 ;
6173 wxSize temp2 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char * kwnames[] = {
6177 (char *) "pos",(char *) "size", NULL
6178 };
6179
6180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6181 {
6182 arg1 = &temp1;
6183 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6184 }
6185 {
6186 arg2 = &temp2;
6187 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6196 return resultobj;
6197 fail:
6198 return NULL;
6199 }
6200
6201
6202 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj = 0;
6204 wxSize *arg1 = 0 ;
6205 wxRect *result = 0 ;
6206 wxSize temp1 ;
6207 PyObject * obj0 = 0 ;
6208 char * kwnames[] = {
6209 (char *) "size", NULL
6210 };
6211
6212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6213 {
6214 arg1 = &temp1;
6215 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6216 }
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6231 PyObject *resultobj = 0;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 void *argp1 = 0 ;
6234 int res1 = 0 ;
6235 PyObject *swig_obj[1] ;
6236
6237 if (!args) SWIG_fail;
6238 swig_obj[0] = args;
6239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6240 if (!SWIG_IsOK(res1)) {
6241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6242 }
6243 arg1 = reinterpret_cast< wxRect * >(argp1);
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 delete arg1;
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_Py_Void();
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6259 PyObject *resultobj = 0;
6260 wxRect *arg1 = (wxRect *) 0 ;
6261 int result;
6262 void *argp1 = 0 ;
6263 int res1 = 0 ;
6264 PyObject *swig_obj[1] ;
6265
6266 if (!args) SWIG_fail;
6267 swig_obj[0] = args;
6268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6269 if (!SWIG_IsOK(res1)) {
6270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6271 }
6272 arg1 = reinterpret_cast< wxRect * >(argp1);
6273 {
6274 PyThreadState* __tstate = wxPyBeginAllowThreads();
6275 result = (int)((wxRect const *)arg1)->GetX();
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 resultobj = SWIG_From_int(static_cast< int >(result));
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj = 0;
6288 wxRect *arg1 = (wxRect *) 0 ;
6289 int arg2 ;
6290 void *argp1 = 0 ;
6291 int res1 = 0 ;
6292 int val2 ;
6293 int ecode2 = 0 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "self",(char *) "x", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6302 if (!SWIG_IsOK(res1)) {
6303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6304 }
6305 arg1 = reinterpret_cast< wxRect * >(argp1);
6306 ecode2 = SWIG_AsVal_int(obj1, &val2);
6307 if (!SWIG_IsOK(ecode2)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6309 }
6310 arg2 = static_cast< int >(val2);
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 (arg1)->SetX(arg2);
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 resultobj = SWIG_Py_Void();
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6325 PyObject *resultobj = 0;
6326 wxRect *arg1 = (wxRect *) 0 ;
6327 int result;
6328 void *argp1 = 0 ;
6329 int res1 = 0 ;
6330 PyObject *swig_obj[1] ;
6331
6332 if (!args) SWIG_fail;
6333 swig_obj[0] = args;
6334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6335 if (!SWIG_IsOK(res1)) {
6336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6337 }
6338 arg1 = reinterpret_cast< wxRect * >(argp1);
6339 {
6340 PyThreadState* __tstate = wxPyBeginAllowThreads();
6341 result = (int)(arg1)->GetY();
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 resultobj = SWIG_From_int(static_cast< int >(result));
6346 return resultobj;
6347 fail:
6348 return NULL;
6349 }
6350
6351
6352 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6353 PyObject *resultobj = 0;
6354 wxRect *arg1 = (wxRect *) 0 ;
6355 int arg2 ;
6356 void *argp1 = 0 ;
6357 int res1 = 0 ;
6358 int val2 ;
6359 int ecode2 = 0 ;
6360 PyObject * obj0 = 0 ;
6361 PyObject * obj1 = 0 ;
6362 char * kwnames[] = {
6363 (char *) "self",(char *) "y", NULL
6364 };
6365
6366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6368 if (!SWIG_IsOK(res1)) {
6369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6370 }
6371 arg1 = reinterpret_cast< wxRect * >(argp1);
6372 ecode2 = SWIG_AsVal_int(obj1, &val2);
6373 if (!SWIG_IsOK(ecode2)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6375 }
6376 arg2 = static_cast< int >(val2);
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 (arg1)->SetY(arg2);
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 resultobj = SWIG_Py_Void();
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6391 PyObject *resultobj = 0;
6392 wxRect *arg1 = (wxRect *) 0 ;
6393 int result;
6394 void *argp1 = 0 ;
6395 int res1 = 0 ;
6396 PyObject *swig_obj[1] ;
6397
6398 if (!args) SWIG_fail;
6399 swig_obj[0] = args;
6400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6401 if (!SWIG_IsOK(res1)) {
6402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6403 }
6404 arg1 = reinterpret_cast< wxRect * >(argp1);
6405 {
6406 PyThreadState* __tstate = wxPyBeginAllowThreads();
6407 result = (int)((wxRect const *)arg1)->GetWidth();
6408 wxPyEndAllowThreads(__tstate);
6409 if (PyErr_Occurred()) SWIG_fail;
6410 }
6411 resultobj = SWIG_From_int(static_cast< int >(result));
6412 return resultobj;
6413 fail:
6414 return NULL;
6415 }
6416
6417
6418 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6419 PyObject *resultobj = 0;
6420 wxRect *arg1 = (wxRect *) 0 ;
6421 int arg2 ;
6422 void *argp1 = 0 ;
6423 int res1 = 0 ;
6424 int val2 ;
6425 int ecode2 = 0 ;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char * kwnames[] = {
6429 (char *) "self",(char *) "w", NULL
6430 };
6431
6432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6434 if (!SWIG_IsOK(res1)) {
6435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6436 }
6437 arg1 = reinterpret_cast< wxRect * >(argp1);
6438 ecode2 = SWIG_AsVal_int(obj1, &val2);
6439 if (!SWIG_IsOK(ecode2)) {
6440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6441 }
6442 arg2 = static_cast< int >(val2);
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 (arg1)->SetWidth(arg2);
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 resultobj = SWIG_Py_Void();
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6457 PyObject *resultobj = 0;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 int result;
6460 void *argp1 = 0 ;
6461 int res1 = 0 ;
6462 PyObject *swig_obj[1] ;
6463
6464 if (!args) SWIG_fail;
6465 swig_obj[0] = args;
6466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6467 if (!SWIG_IsOK(res1)) {
6468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6469 }
6470 arg1 = reinterpret_cast< wxRect * >(argp1);
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (int)((wxRect const *)arg1)->GetHeight();
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_From_int(static_cast< int >(result));
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 int arg2 ;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 int val2 ;
6491 int ecode2 = 0 ;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 char * kwnames[] = {
6495 (char *) "self",(char *) "h", NULL
6496 };
6497
6498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6500 if (!SWIG_IsOK(res1)) {
6501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6502 }
6503 arg1 = reinterpret_cast< wxRect * >(argp1);
6504 ecode2 = SWIG_AsVal_int(obj1, &val2);
6505 if (!SWIG_IsOK(ecode2)) {
6506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6507 }
6508 arg2 = static_cast< int >(val2);
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 (arg1)->SetHeight(arg2);
6512 wxPyEndAllowThreads(__tstate);
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_Py_Void();
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 wxPoint result;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 PyObject *swig_obj[1] ;
6529
6530 if (!args) SWIG_fail;
6531 swig_obj[0] = args;
6532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6533 if (!SWIG_IsOK(res1)) {
6534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6535 }
6536 arg1 = reinterpret_cast< wxRect * >(argp1);
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = ((wxRect const *)arg1)->GetPosition();
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj = 0;
6552 wxRect *arg1 = (wxRect *) 0 ;
6553 wxPoint *arg2 = 0 ;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 wxPoint temp2 ;
6557 PyObject * obj0 = 0 ;
6558 PyObject * obj1 = 0 ;
6559 char * kwnames[] = {
6560 (char *) "self",(char *) "p", NULL
6561 };
6562
6563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 {
6570 arg2 = &temp2;
6571 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 (arg1)->SetPosition((wxPoint const &)*arg2);
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_Py_Void();
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 PyObject *resultobj = 0;
6588 wxRect *arg1 = (wxRect *) 0 ;
6589 wxSize result;
6590 void *argp1 = 0 ;
6591 int res1 = 0 ;
6592 PyObject *swig_obj[1] ;
6593
6594 if (!args) SWIG_fail;
6595 swig_obj[0] = args;
6596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6597 if (!SWIG_IsOK(res1)) {
6598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6599 }
6600 arg1 = reinterpret_cast< wxRect * >(argp1);
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = ((wxRect const *)arg1)->GetSize();
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = 0;
6616 wxRect *arg1 = (wxRect *) 0 ;
6617 wxSize *arg2 = 0 ;
6618 void *argp1 = 0 ;
6619 int res1 = 0 ;
6620 wxSize temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char * kwnames[] = {
6624 (char *) "self",(char *) "s", NULL
6625 };
6626
6627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6629 if (!SWIG_IsOK(res1)) {
6630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6631 }
6632 arg1 = reinterpret_cast< wxRect * >(argp1);
6633 {
6634 arg2 = &temp2;
6635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6636 }
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 (arg1)->SetSize((wxSize const &)*arg2);
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_Py_Void();
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 bool result;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 PyObject *swig_obj[1] ;
6657
6658 if (!args) SWIG_fail;
6659 swig_obj[0] = args;
6660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 PyThreadState* __tstate = wxPyBeginAllowThreads();
6667 result = (bool)((wxRect const *)arg1)->IsEmpty();
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 {
6672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6673 }
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxPoint result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 result = ((wxRect const *)arg1)->GetTopLeft();
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6709 PyObject *resultobj = 0;
6710 wxRect *arg1 = (wxRect *) 0 ;
6711 wxPoint *arg2 = 0 ;
6712 void *argp1 = 0 ;
6713 int res1 = 0 ;
6714 wxPoint temp2 ;
6715 PyObject * obj0 = 0 ;
6716 PyObject * obj1 = 0 ;
6717 char * kwnames[] = {
6718 (char *) "self",(char *) "p", NULL
6719 };
6720
6721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6723 if (!SWIG_IsOK(res1)) {
6724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6725 }
6726 arg1 = reinterpret_cast< wxRect * >(argp1);
6727 {
6728 arg2 = &temp2;
6729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6730 }
6731 {
6732 PyThreadState* __tstate = wxPyBeginAllowThreads();
6733 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 resultobj = SWIG_Py_Void();
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6745 PyObject *resultobj = 0;
6746 wxRect *arg1 = (wxRect *) 0 ;
6747 wxPoint result;
6748 void *argp1 = 0 ;
6749 int res1 = 0 ;
6750 PyObject *swig_obj[1] ;
6751
6752 if (!args) SWIG_fail;
6753 swig_obj[0] = args;
6754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6755 if (!SWIG_IsOK(res1)) {
6756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6757 }
6758 arg1 = reinterpret_cast< wxRect * >(argp1);
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = ((wxRect const *)arg1)->GetBottomRight();
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj = 0;
6774 wxRect *arg1 = (wxRect *) 0 ;
6775 wxPoint *arg2 = 0 ;
6776 void *argp1 = 0 ;
6777 int res1 = 0 ;
6778 wxPoint temp2 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "p", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_Py_Void();
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 int result;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 PyObject *swig_obj[1] ;
6815
6816 if (!args) SWIG_fail;
6817 swig_obj[0] = args;
6818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6819 if (!SWIG_IsOK(res1)) {
6820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6821 }
6822 arg1 = reinterpret_cast< wxRect * >(argp1);
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (int)((wxRect const *)arg1)->GetLeft();
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 resultobj = SWIG_From_int(static_cast< int >(result));
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6837 PyObject *resultobj = 0;
6838 wxRect *arg1 = (wxRect *) 0 ;
6839 int result;
6840 void *argp1 = 0 ;
6841 int res1 = 0 ;
6842 PyObject *swig_obj[1] ;
6843
6844 if (!args) SWIG_fail;
6845 swig_obj[0] = args;
6846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6847 if (!SWIG_IsOK(res1)) {
6848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6849 }
6850 arg1 = reinterpret_cast< wxRect * >(argp1);
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (int)((wxRect const *)arg1)->GetTop();
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_From_int(static_cast< int >(result));
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6865 PyObject *resultobj = 0;
6866 wxRect *arg1 = (wxRect *) 0 ;
6867 int result;
6868 void *argp1 = 0 ;
6869 int res1 = 0 ;
6870 PyObject *swig_obj[1] ;
6871
6872 if (!args) SWIG_fail;
6873 swig_obj[0] = args;
6874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6877 }
6878 arg1 = reinterpret_cast< wxRect * >(argp1);
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (int)((wxRect const *)arg1)->GetBottom();
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_From_int(static_cast< int >(result));
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6893 PyObject *resultobj = 0;
6894 wxRect *arg1 = (wxRect *) 0 ;
6895 int result;
6896 void *argp1 = 0 ;
6897 int res1 = 0 ;
6898 PyObject *swig_obj[1] ;
6899
6900 if (!args) SWIG_fail;
6901 swig_obj[0] = args;
6902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = (int)((wxRect const *)arg1)->GetRight();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_From_int(static_cast< int >(result));
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 int arg2 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 int val2 ;
6927 int ecode2 = 0 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "self",(char *) "left", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 ecode2 = SWIG_AsVal_int(obj1, &val2);
6941 if (!SWIG_IsOK(ecode2)) {
6942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6943 }
6944 arg2 = static_cast< int >(val2);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 (arg1)->SetLeft(arg2);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_Py_Void();
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxRect *arg1 = (wxRect *) 0 ;
6961 int arg2 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 int val2 ;
6965 int ecode2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "right", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 ecode2 = SWIG_AsVal_int(obj1, &val2);
6979 if (!SWIG_IsOK(ecode2)) {
6980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6981 }
6982 arg2 = static_cast< int >(val2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetRight(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int arg2 ;
7000 void *argp1 = 0 ;
7001 int res1 = 0 ;
7002 int val2 ;
7003 int ecode2 = 0 ;
7004 PyObject * obj0 = 0 ;
7005 PyObject * obj1 = 0 ;
7006 char * kwnames[] = {
7007 (char *) "self",(char *) "top", NULL
7008 };
7009
7010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7014 }
7015 arg1 = reinterpret_cast< wxRect * >(argp1);
7016 ecode2 = SWIG_AsVal_int(obj1, &val2);
7017 if (!SWIG_IsOK(ecode2)) {
7018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7019 }
7020 arg2 = static_cast< int >(val2);
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 (arg1)->SetTop(arg2);
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_Py_Void();
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int arg2 ;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 int val2 ;
7041 int ecode2 = 0 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char * kwnames[] = {
7045 (char *) "self",(char *) "bottom", NULL
7046 };
7047
7048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7050 if (!SWIG_IsOK(res1)) {
7051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7052 }
7053 arg1 = reinterpret_cast< wxRect * >(argp1);
7054 ecode2 = SWIG_AsVal_int(obj1, &val2);
7055 if (!SWIG_IsOK(ecode2)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7057 }
7058 arg2 = static_cast< int >(val2);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->SetBottom(arg2);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int arg2 ;
7076 int arg3 ;
7077 wxRect *result = 0 ;
7078 void *argp1 = 0 ;
7079 int res1 = 0 ;
7080 int val2 ;
7081 int ecode2 = 0 ;
7082 int val3 ;
7083 int ecode3 = 0 ;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 PyObject * obj2 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "self",(char *) "dx",(char *) "dy", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 ecode2 = SWIG_AsVal_int(obj1, &val2);
7098 if (!SWIG_IsOK(ecode2)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7100 }
7101 arg2 = static_cast< int >(val2);
7102 ecode3 = SWIG_AsVal_int(obj2, &val3);
7103 if (!SWIG_IsOK(ecode3)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7105 }
7106 arg3 = static_cast< int >(val3);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 {
7110 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7111 result = (wxRect *) &_result_ref;
7112 }
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 wxRect *result = 0 ;
7129 void *argp1 = 0 ;
7130 int res1 = 0 ;
7131 int val2 ;
7132 int ecode2 = 0 ;
7133 int val3 ;
7134 int ecode3 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 PyObject * obj2 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "dx",(char *) "dy", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 ecode3 = SWIG_AsVal_int(obj2, &val3);
7154 if (!SWIG_IsOK(ecode3)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7156 }
7157 arg3 = static_cast< int >(val3);
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 {
7161 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7162 result = (wxRect *) &_result_ref;
7163 }
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxRect *arg1 = (wxRect *) 0 ;
7177 int arg2 ;
7178 int arg3 ;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 int val2 ;
7182 int ecode2 = 0 ;
7183 int val3 ;
7184 int ecode3 = 0 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 PyObject * obj2 = 0 ;
7188 char * kwnames[] = {
7189 (char *) "self",(char *) "dx",(char *) "dy", NULL
7190 };
7191
7192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7196 }
7197 arg1 = reinterpret_cast< wxRect * >(argp1);
7198 ecode2 = SWIG_AsVal_int(obj1, &val2);
7199 if (!SWIG_IsOK(ecode2)) {
7200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7201 }
7202 arg2 = static_cast< int >(val2);
7203 ecode3 = SWIG_AsVal_int(obj2, &val3);
7204 if (!SWIG_IsOK(ecode3)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7206 }
7207 arg3 = static_cast< int >(val3);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 (arg1)->Offset(arg2,arg3);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_Py_Void();
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxRect *arg1 = (wxRect *) 0 ;
7224 wxPoint *arg2 = 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 wxPoint temp2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "pt", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 {
7241 arg2 = &temp2;
7242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7243 }
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 (arg1)->Offset((wxPoint const &)*arg2);
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_Py_Void();
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 wxRect result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (arg1)->Intersect((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 wxRect *arg2 = 0 ;
7298 wxRect result;
7299 void *argp1 = 0 ;
7300 int res1 = 0 ;
7301 wxRect temp2 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "rect", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 {
7315 arg2 = &temp2;
7316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (arg1)->Union((wxRect const &)*arg2);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj = 0;
7333 wxRect *arg1 = (wxRect *) 0 ;
7334 wxRect *arg2 = 0 ;
7335 wxRect result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 wxRect temp2 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "rect", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7349 }
7350 arg1 = reinterpret_cast< wxRect * >(argp1);
7351 {
7352 arg2 = &temp2;
7353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7354 }
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 wxRect *arg2 = 0 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 wxRect temp2 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char * kwnames[] = {
7379 (char *) "self",(char *) "rect", NULL
7380 };
7381
7382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7386 }
7387 arg1 = reinterpret_cast< wxRect * >(argp1);
7388 {
7389 arg2 = &temp2;
7390 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7391 }
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 {
7395 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7396 result = (wxRect *) &_result_ref;
7397 }
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj = 0;
7410 wxRect *arg1 = (wxRect *) 0 ;
7411 PyObject *arg2 = (PyObject *) 0 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 char * kwnames[] = {
7418 (char *) "self",(char *) "other", NULL
7419 };
7420
7421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7423 if (!SWIG_IsOK(res1)) {
7424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7425 }
7426 arg1 = reinterpret_cast< wxRect * >(argp1);
7427 arg2 = obj1;
7428 {
7429 result = (bool)wxRect___eq__(arg1,arg2);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 PyObject *arg2 = (PyObject *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "other", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7458 }
7459 arg1 = reinterpret_cast< wxRect * >(argp1);
7460 arg2 = obj1;
7461 {
7462 result = (bool)wxRect___ne__(arg1,arg2);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 {
7466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7467 }
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj = 0;
7476 wxRect *arg1 = (wxRect *) 0 ;
7477 int arg2 ;
7478 int arg3 ;
7479 bool result;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 int val2 ;
7483 int ecode2 = 0 ;
7484 int val3 ;
7485 int ecode3 = 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 PyObject * obj2 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "x",(char *) "y", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7497 }
7498 arg1 = reinterpret_cast< wxRect * >(argp1);
7499 ecode2 = SWIG_AsVal_int(obj1, &val2);
7500 if (!SWIG_IsOK(ecode2)) {
7501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7502 }
7503 arg2 = static_cast< int >(val2);
7504 ecode3 = SWIG_AsVal_int(obj2, &val3);
7505 if (!SWIG_IsOK(ecode3)) {
7506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7507 }
7508 arg3 = static_cast< int >(val3);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj = 0;
7526 wxRect *arg1 = (wxRect *) 0 ;
7527 wxPoint *arg2 = 0 ;
7528 bool result;
7529 void *argp1 = 0 ;
7530 int res1 = 0 ;
7531 wxPoint temp2 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 char * kwnames[] = {
7535 (char *) "self",(char *) "pt", NULL
7536 };
7537
7538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7540 if (!SWIG_IsOK(res1)) {
7541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7542 }
7543 arg1 = reinterpret_cast< wxRect * >(argp1);
7544 {
7545 arg2 = &temp2;
7546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7547 }
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 {
7555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7556 }
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj = 0;
7565 wxRect *arg1 = (wxRect *) 0 ;
7566 wxRect *arg2 = 0 ;
7567 bool result;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 wxRect temp2 ;
7571 PyObject * obj0 = 0 ;
7572 PyObject * obj1 = 0 ;
7573 char * kwnames[] = {
7574 (char *) "self",(char *) "rect", NULL
7575 };
7576
7577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7579 if (!SWIG_IsOK(res1)) {
7580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7581 }
7582 arg1 = reinterpret_cast< wxRect * >(argp1);
7583 {
7584 arg2 = &temp2;
7585 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7586 }
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 wxRect *arg2 = 0 ;
7606 int arg3 = (int) wxBOTH ;
7607 wxRect result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 wxRect temp2 ;
7611 int val3 ;
7612 int ecode3 = 0 ;
7613 PyObject * obj0 = 0 ;
7614 PyObject * obj1 = 0 ;
7615 PyObject * obj2 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "r",(char *) "dir", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 if (obj2) {
7631 ecode3 = SWIG_AsVal_int(obj2, &val3);
7632 if (!SWIG_IsOK(ecode3)) {
7633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7634 }
7635 arg3 = static_cast< int >(val3);
7636 }
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7651 PyObject *resultobj = 0;
7652 wxRect *arg1 = (wxRect *) 0 ;
7653 int arg2 ;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 int val2 ;
7657 int ecode2 = 0 ;
7658 PyObject *swig_obj[2] ;
7659
7660 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7664 }
7665 arg1 = reinterpret_cast< wxRect * >(argp1);
7666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7667 if (!SWIG_IsOK(ecode2)) {
7668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7669 }
7670 arg2 = static_cast< int >(val2);
7671 if (arg1) (arg1)->x = arg2;
7672
7673 resultobj = SWIG_Py_Void();
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 int result;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 PyObject *swig_obj[1] ;
7687
7688 if (!args) SWIG_fail;
7689 swig_obj[0] = args;
7690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7693 }
7694 arg1 = reinterpret_cast< wxRect * >(argp1);
7695 result = (int) ((arg1)->x);
7696 resultobj = SWIG_From_int(static_cast< int >(result));
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 int arg2 ;
7707 void *argp1 = 0 ;
7708 int res1 = 0 ;
7709 int val2 ;
7710 int ecode2 = 0 ;
7711 PyObject *swig_obj[2] ;
7712
7713 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7717 }
7718 arg1 = reinterpret_cast< wxRect * >(argp1);
7719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7722 }
7723 arg2 = static_cast< int >(val2);
7724 if (arg1) (arg1)->y = arg2;
7725
7726 resultobj = SWIG_Py_Void();
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 PyObject *resultobj = 0;
7735 wxRect *arg1 = (wxRect *) 0 ;
7736 int result;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 PyObject *swig_obj[1] ;
7740
7741 if (!args) SWIG_fail;
7742 swig_obj[0] = args;
7743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7744 if (!SWIG_IsOK(res1)) {
7745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7746 }
7747 arg1 = reinterpret_cast< wxRect * >(argp1);
7748 result = (int) ((arg1)->y);
7749 resultobj = SWIG_From_int(static_cast< int >(result));
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7757 PyObject *resultobj = 0;
7758 wxRect *arg1 = (wxRect *) 0 ;
7759 int arg2 ;
7760 void *argp1 = 0 ;
7761 int res1 = 0 ;
7762 int val2 ;
7763 int ecode2 = 0 ;
7764 PyObject *swig_obj[2] ;
7765
7766 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7773 if (!SWIG_IsOK(ecode2)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7775 }
7776 arg2 = static_cast< int >(val2);
7777 if (arg1) (arg1)->width = arg2;
7778
7779 resultobj = SWIG_Py_Void();
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 PyObject *resultobj = 0;
7788 wxRect *arg1 = (wxRect *) 0 ;
7789 int result;
7790 void *argp1 = 0 ;
7791 int res1 = 0 ;
7792 PyObject *swig_obj[1] ;
7793
7794 if (!args) SWIG_fail;
7795 swig_obj[0] = args;
7796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7799 }
7800 arg1 = reinterpret_cast< wxRect * >(argp1);
7801 result = (int) ((arg1)->width);
7802 resultobj = SWIG_From_int(static_cast< int >(result));
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *resultobj = 0;
7811 wxRect *arg1 = (wxRect *) 0 ;
7812 int arg2 ;
7813 void *argp1 = 0 ;
7814 int res1 = 0 ;
7815 int val2 ;
7816 int ecode2 = 0 ;
7817 PyObject *swig_obj[2] ;
7818
7819 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7826 if (!SWIG_IsOK(ecode2)) {
7827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7828 }
7829 arg2 = static_cast< int >(val2);
7830 if (arg1) (arg1)->height = arg2;
7831
7832 resultobj = SWIG_Py_Void();
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7840 PyObject *resultobj = 0;
7841 wxRect *arg1 = (wxRect *) 0 ;
7842 int result;
7843 void *argp1 = 0 ;
7844 int res1 = 0 ;
7845 PyObject *swig_obj[1] ;
7846
7847 if (!args) SWIG_fail;
7848 swig_obj[0] = args;
7849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7852 }
7853 arg1 = reinterpret_cast< wxRect * >(argp1);
7854 result = (int) ((arg1)->height);
7855 resultobj = SWIG_From_int(static_cast< int >(result));
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 = (int) 0 ;
7866 int arg3 = (int) 0 ;
7867 int arg4 = (int) 0 ;
7868 int arg5 = (int) 0 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 int val2 ;
7872 int ecode2 = 0 ;
7873 int val3 ;
7874 int ecode3 = 0 ;
7875 int val4 ;
7876 int ecode4 = 0 ;
7877 int val5 ;
7878 int ecode5 = 0 ;
7879 PyObject * obj0 = 0 ;
7880 PyObject * obj1 = 0 ;
7881 PyObject * obj2 = 0 ;
7882 PyObject * obj3 = 0 ;
7883 PyObject * obj4 = 0 ;
7884 char * kwnames[] = {
7885 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7886 };
7887
7888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7890 if (!SWIG_IsOK(res1)) {
7891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7892 }
7893 arg1 = reinterpret_cast< wxRect * >(argp1);
7894 if (obj1) {
7895 ecode2 = SWIG_AsVal_int(obj1, &val2);
7896 if (!SWIG_IsOK(ecode2)) {
7897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7898 }
7899 arg2 = static_cast< int >(val2);
7900 }
7901 if (obj2) {
7902 ecode3 = SWIG_AsVal_int(obj2, &val3);
7903 if (!SWIG_IsOK(ecode3)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7905 }
7906 arg3 = static_cast< int >(val3);
7907 }
7908 if (obj3) {
7909 ecode4 = SWIG_AsVal_int(obj3, &val4);
7910 if (!SWIG_IsOK(ecode4)) {
7911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7912 }
7913 arg4 = static_cast< int >(val4);
7914 }
7915 if (obj4) {
7916 ecode5 = SWIG_AsVal_int(obj4, &val5);
7917 if (!SWIG_IsOK(ecode5)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7919 }
7920 arg5 = static_cast< int >(val5);
7921 }
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 resultobj = SWIG_Py_Void();
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *resultobj = 0;
7937 wxRect *arg1 = (wxRect *) 0 ;
7938 PyObject *result = 0 ;
7939 void *argp1 = 0 ;
7940 int res1 = 0 ;
7941 PyObject *swig_obj[1] ;
7942
7943 if (!args) SWIG_fail;
7944 swig_obj[0] = args;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (PyObject *)wxRect_Get(arg1);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = result;
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *obj;
7965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7966 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7967 return SWIG_Py_Void();
7968 }
7969
7970 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 return SWIG_Python_InitShadowInstance(args);
7972 }
7973
7974 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxRect *arg1 = (wxRect *) 0 ;
7977 wxRect *arg2 = (wxRect *) 0 ;
7978 PyObject *result = 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 void *argp2 = 0 ;
7982 int res2 = 0 ;
7983 PyObject * obj0 = 0 ;
7984 PyObject * obj1 = 0 ;
7985 char * kwnames[] = {
7986 (char *) "r1",(char *) "r2", NULL
7987 };
7988
7989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7991 if (!SWIG_IsOK(res1)) {
7992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7993 }
7994 arg1 = reinterpret_cast< wxRect * >(argp1);
7995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7996 if (!SWIG_IsOK(res2)) {
7997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7998 }
7999 arg2 = reinterpret_cast< wxRect * >(argp2);
8000 {
8001 if (!wxPyCheckForApp()) SWIG_fail;
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 result = (PyObject *)wxIntersectRect(arg1,arg2);
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 resultobj = result;
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj = 0;
8016 double arg1 = (double) 0.0 ;
8017 double arg2 = (double) 0.0 ;
8018 wxPoint2D *result = 0 ;
8019 double val1 ;
8020 int ecode1 = 0 ;
8021 double val2 ;
8022 int ecode2 = 0 ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char * kwnames[] = {
8026 (char *) "x",(char *) "y", NULL
8027 };
8028
8029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8030 if (obj0) {
8031 ecode1 = SWIG_AsVal_double(obj0, &val1);
8032 if (!SWIG_IsOK(ecode1)) {
8033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8034 }
8035 arg1 = static_cast< double >(val1);
8036 }
8037 if (obj1) {
8038 ecode2 = SWIG_AsVal_double(obj1, &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8041 }
8042 arg2 = static_cast< double >(val2);
8043 }
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 wxPoint2D *arg1 = 0 ;
8060 wxPoint2D *result = 0 ;
8061 wxPoint2D temp1 ;
8062 PyObject * obj0 = 0 ;
8063 char * kwnames[] = {
8064 (char *) "pt", NULL
8065 };
8066
8067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8068 {
8069 arg1 = &temp1;
8070 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8071 }
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj = 0;
8087 wxPoint *arg1 = 0 ;
8088 wxPoint2D *result = 0 ;
8089 wxPoint temp1 ;
8090 PyObject * obj0 = 0 ;
8091 char * kwnames[] = {
8092 (char *) "pt", NULL
8093 };
8094
8095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8096 {
8097 arg1 = &temp1;
8098 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8114 PyObject *resultobj = 0;
8115 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8116 int *arg2 = (int *) 0 ;
8117 int *arg3 = (int *) 0 ;
8118 void *argp1 = 0 ;
8119 int res1 = 0 ;
8120 int temp2 ;
8121 int res2 = SWIG_TMPOBJ ;
8122 int temp3 ;
8123 int res3 = SWIG_TMPOBJ ;
8124 PyObject *swig_obj[1] ;
8125
8126 arg2 = &temp2;
8127 arg3 = &temp3;
8128 if (!args) SWIG_fail;
8129 swig_obj[0] = args;
8130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8131 if (!SWIG_IsOK(res1)) {
8132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8133 }
8134 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 if (SWIG_IsTmpObj(res2)) {
8143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8144 } else {
8145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8147 }
8148 if (SWIG_IsTmpObj(res3)) {
8149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8150 } else {
8151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8153 }
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8161 PyObject *resultobj = 0;
8162 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8163 int *arg2 = (int *) 0 ;
8164 int *arg3 = (int *) 0 ;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 int temp2 ;
8168 int res2 = SWIG_TMPOBJ ;
8169 int temp3 ;
8170 int res3 = SWIG_TMPOBJ ;
8171 PyObject *swig_obj[1] ;
8172
8173 arg2 = &temp2;
8174 arg3 = &temp3;
8175 if (!args) SWIG_fail;
8176 swig_obj[0] = args;
8177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_Py_Void();
8189 if (SWIG_IsTmpObj(res2)) {
8190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8191 } else {
8192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8194 }
8195 if (SWIG_IsTmpObj(res3)) {
8196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8197 } else {
8198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8210 double result;
8211 void *argp1 = 0 ;
8212 int res1 = 0 ;
8213 PyObject *swig_obj[1] ;
8214
8215 if (!args) SWIG_fail;
8216 swig_obj[0] = args;
8217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_From_double(static_cast< double >(result));
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8236 PyObject *resultobj = 0;
8237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8238 double result;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 PyObject *swig_obj[1] ;
8242
8243 if (!args) SWIG_fail;
8244 swig_obj[0] = args;
8245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8248 }
8249 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_From_double(static_cast< double >(result));
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8266 double arg2 ;
8267 void *argp1 = 0 ;
8268 int res1 = 0 ;
8269 double val2 ;
8270 int ecode2 = 0 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "length", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8281 }
8282 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8283 ecode2 = SWIG_AsVal_double(obj1, &val2);
8284 if (!SWIG_IsOK(ecode2)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8286 }
8287 arg2 = static_cast< double >(val2);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 (arg1)->SetVectorLength(arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = SWIG_Py_Void();
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8304 double arg2 ;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 double val2 ;
8308 int ecode2 = 0 ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 char * kwnames[] = {
8312 (char *) "self",(char *) "degrees", NULL
8313 };
8314
8315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8317 if (!SWIG_IsOK(res1)) {
8318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8319 }
8320 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 (arg1)->SetVectorAngle(arg2);
8329 wxPyEndAllowThreads(__tstate);
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_Py_Void();
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 wxPoint2D *arg2 = 0 ;
8343 double result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 wxPoint2D temp2 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char * kwnames[] = {
8350 (char *) "self",(char *) "pt", NULL
8351 };
8352
8353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8357 }
8358 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8359 {
8360 arg2 = &temp2;
8361 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8362 }
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_From_double(static_cast< double >(result));
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 double result;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_From_double(static_cast< double >(result));
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 wxPoint2D *arg2 = 0 ;
8417 double result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxPoint2D temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "self",(char *) "vec", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8431 }
8432 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_From_double(static_cast< double >(result));
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj = 0;
8452 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8453 wxPoint2D *arg2 = 0 ;
8454 double result;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 wxPoint2D temp2 ;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 char * kwnames[] = {
8461 (char *) "self",(char *) "vec", NULL
8462 };
8463
8464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8468 }
8469 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8470 {
8471 arg2 = &temp2;
8472 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8473 }
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_From_double(static_cast< double >(result));
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 wxPoint2D result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->operator -();
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj = 0;
8517 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8518 wxPoint2D *arg2 = 0 ;
8519 wxPoint2D *result = 0 ;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 wxPoint2D temp2 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 char * kwnames[] = {
8526 (char *) "self",(char *) "pt", NULL
8527 };
8528
8529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8531 if (!SWIG_IsOK(res1)) {
8532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8533 }
8534 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8535 {
8536 arg2 = &temp2;
8537 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8538 }
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 {
8542 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8543 result = (wxPoint2D *) &_result_ref;
8544 }
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 wxPoint2D *result = 0 ;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 {
8582 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8583 result = (wxPoint2D *) &_result_ref;
8584 }
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj = 0;
8597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8598 wxPoint2D *arg2 = 0 ;
8599 wxPoint2D *result = 0 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 wxPoint2D temp2 ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char * kwnames[] = {
8606 (char *) "self",(char *) "pt", NULL
8607 };
8608
8609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8613 }
8614 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8615 {
8616 arg2 = &temp2;
8617 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 {
8622 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8623 result = (wxPoint2D *) &_result_ref;
8624 }
8625 wxPyEndAllowThreads(__tstate);
8626 if (PyErr_Occurred()) SWIG_fail;
8627 }
8628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj = 0;
8637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8638 wxPoint2D *arg2 = 0 ;
8639 wxPoint2D *result = 0 ;
8640 void *argp1 = 0 ;
8641 int res1 = 0 ;
8642 wxPoint2D temp2 ;
8643 PyObject * obj0 = 0 ;
8644 PyObject * obj1 = 0 ;
8645 char * kwnames[] = {
8646 (char *) "self",(char *) "pt", NULL
8647 };
8648
8649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8651 if (!SWIG_IsOK(res1)) {
8652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8653 }
8654 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8655 {
8656 arg2 = &temp2;
8657 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 {
8662 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8663 result = (wxPoint2D *) &_result_ref;
8664 }
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8669 return resultobj;
8670 fail:
8671 return NULL;
8672 }
8673
8674
8675 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8676 PyObject *resultobj = 0;
8677 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8678 PyObject *arg2 = (PyObject *) 0 ;
8679 bool result;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 PyObject * obj0 = 0 ;
8683 PyObject * obj1 = 0 ;
8684 char * kwnames[] = {
8685 (char *) "self",(char *) "other", NULL
8686 };
8687
8688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 arg2 = obj1;
8695 {
8696 result = (bool)wxPoint2D___eq__(arg1,arg2);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 {
8700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8701 }
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 PyObject *arg2 = (PyObject *) 0 ;
8712 bool result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 PyObject * obj0 = 0 ;
8716 PyObject * obj1 = 0 ;
8717 char * kwnames[] = {
8718 (char *) "self",(char *) "other", NULL
8719 };
8720
8721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8725 }
8726 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8727 arg2 = obj1;
8728 {
8729 result = (bool)wxPoint2D___ne__(arg1,arg2);
8730 if (PyErr_Occurred()) SWIG_fail;
8731 }
8732 {
8733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8734 }
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8742 PyObject *resultobj = 0;
8743 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8744 double arg2 ;
8745 void *argp1 = 0 ;
8746 int res1 = 0 ;
8747 double val2 ;
8748 int ecode2 = 0 ;
8749 PyObject *swig_obj[2] ;
8750
8751 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8753 if (!SWIG_IsOK(res1)) {
8754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8755 }
8756 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8757 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8758 if (!SWIG_IsOK(ecode2)) {
8759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8760 }
8761 arg2 = static_cast< double >(val2);
8762 if (arg1) (arg1)->m_x = arg2;
8763
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 double result;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 result = (double) ((arg1)->m_x);
8787 resultobj = SWIG_From_double(static_cast< double >(result));
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8795 PyObject *resultobj = 0;
8796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8797 double arg2 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 double val2 ;
8801 int ecode2 = 0 ;
8802 PyObject *swig_obj[2] ;
8803
8804 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8808 }
8809 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8810 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8811 if (!SWIG_IsOK(ecode2)) {
8812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8813 }
8814 arg2 = static_cast< double >(val2);
8815 if (arg1) (arg1)->m_y = arg2;
8816
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8825 PyObject *resultobj = 0;
8826 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8827 double result;
8828 void *argp1 = 0 ;
8829 int res1 = 0 ;
8830 PyObject *swig_obj[1] ;
8831
8832 if (!args) SWIG_fail;
8833 swig_obj[0] = args;
8834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8835 if (!SWIG_IsOK(res1)) {
8836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8837 }
8838 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8839 result = (double) ((arg1)->m_y);
8840 resultobj = SWIG_From_double(static_cast< double >(result));
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj = 0;
8849 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8850 double arg2 = (double) 0 ;
8851 double arg3 = (double) 0 ;
8852 void *argp1 = 0 ;
8853 int res1 = 0 ;
8854 double val2 ;
8855 int ecode2 = 0 ;
8856 double val3 ;
8857 int ecode3 = 0 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 PyObject * obj2 = 0 ;
8861 char * kwnames[] = {
8862 (char *) "self",(char *) "x",(char *) "y", NULL
8863 };
8864
8865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8867 if (!SWIG_IsOK(res1)) {
8868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8869 }
8870 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8871 if (obj1) {
8872 ecode2 = SWIG_AsVal_double(obj1, &val2);
8873 if (!SWIG_IsOK(ecode2)) {
8874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8875 }
8876 arg2 = static_cast< double >(val2);
8877 }
8878 if (obj2) {
8879 ecode3 = SWIG_AsVal_double(obj2, &val3);
8880 if (!SWIG_IsOK(ecode3)) {
8881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8882 }
8883 arg3 = static_cast< double >(val3);
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 wxPoint2D_Set(arg1,arg2,arg3);
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 resultobj = SWIG_Py_Void();
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8899 PyObject *resultobj = 0;
8900 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8901 PyObject *result = 0 ;
8902 void *argp1 = 0 ;
8903 int res1 = 0 ;
8904 PyObject *swig_obj[1] ;
8905
8906 if (!args) SWIG_fail;
8907 swig_obj[0] = args;
8908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8909 if (!SWIG_IsOK(res1)) {
8910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8911 }
8912 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (PyObject *)wxPoint2D_Get(arg1);
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = result;
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *obj;
8928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8929 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8930 return SWIG_Py_Void();
8931 }
8932
8933 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8934 return SWIG_Python_InitShadowInstance(args);
8935 }
8936
8937 SWIGINTERN int DefaultPosition_set(PyObject *) {
8938 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8939 return 1;
8940 }
8941
8942
8943 SWIGINTERN PyObject *DefaultPosition_get(void) {
8944 PyObject *pyobj = 0;
8945
8946 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8947 return pyobj;
8948 }
8949
8950
8951 SWIGINTERN int DefaultSize_set(PyObject *) {
8952 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8953 return 1;
8954 }
8955
8956
8957 SWIGINTERN PyObject *DefaultSize_get(void) {
8958 PyObject *pyobj = 0;
8959
8960 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8961 return pyobj;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = 0;
8967 PyObject *arg1 = (PyObject *) 0 ;
8968 wxPyInputStream *result = 0 ;
8969 PyObject * obj0 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "p", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8975 arg1 = obj0;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990 PyObject *resultobj = 0;
8991 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8992 void *argp1 = 0 ;
8993 int res1 = 0 ;
8994 PyObject *swig_obj[1] ;
8995
8996 if (!args) SWIG_fail;
8997 swig_obj[0] = args;
8998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9001 }
9002 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 delete arg1;
9006
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = SWIG_Py_Void();
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 PyObject *swig_obj[1] ;
9023
9024 if (!args) SWIG_fail;
9025 swig_obj[0] = args;
9026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9027 if (!SWIG_IsOK(res1)) {
9028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9029 }
9030 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 (arg1)->close();
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 resultobj = SWIG_Py_Void();
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 PyObject *swig_obj[1] ;
9050
9051 if (!args) SWIG_fail;
9052 swig_obj[0] = args;
9053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9054 if (!SWIG_IsOK(res1)) {
9055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9056 }
9057 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 (arg1)->flush();
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 resultobj = SWIG_Py_Void();
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9074 bool result;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 PyObject *swig_obj[1] ;
9078
9079 if (!args) SWIG_fail;
9080 swig_obj[0] = args;
9081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9084 }
9085 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (bool)(arg1)->eof();
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 {
9093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9094 }
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9104 int arg2 = (int) -1 ;
9105 PyObject *result = 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 int val2 ;
9109 int ecode2 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "self",(char *) "size", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9118 if (!SWIG_IsOK(res1)) {
9119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9120 }
9121 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9122 if (obj1) {
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 }
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (PyObject *)(arg1)->read(arg2);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = result;
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9145 int arg2 = (int) -1 ;
9146 PyObject *result = 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 int val2 ;
9150 int ecode2 = 0 ;
9151 PyObject * obj0 = 0 ;
9152 PyObject * obj1 = 0 ;
9153 char * kwnames[] = {
9154 (char *) "self",(char *) "size", NULL
9155 };
9156
9157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 if (obj1) {
9164 ecode2 = SWIG_AsVal_int(obj1, &val2);
9165 if (!SWIG_IsOK(ecode2)) {
9166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9167 }
9168 arg2 = static_cast< int >(val2);
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 result = (PyObject *)(arg1)->readline(arg2);
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 resultobj = result;
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj = 0;
9185 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9186 int arg2 = (int) -1 ;
9187 PyObject *result = 0 ;
9188 void *argp1 = 0 ;
9189 int res1 = 0 ;
9190 int val2 ;
9191 int ecode2 = 0 ;
9192 PyObject * obj0 = 0 ;
9193 PyObject * obj1 = 0 ;
9194 char * kwnames[] = {
9195 (char *) "self",(char *) "sizehint", NULL
9196 };
9197
9198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9202 }
9203 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9204 if (obj1) {
9205 ecode2 = SWIG_AsVal_int(obj1, &val2);
9206 if (!SWIG_IsOK(ecode2)) {
9207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9208 }
9209 arg2 = static_cast< int >(val2);
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (PyObject *)(arg1)->readlines(arg2);
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = result;
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = 0;
9226 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9227 int arg2 ;
9228 int arg3 = (int) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 int val2 ;
9232 int ecode2 = 0 ;
9233 int val3 ;
9234 int ecode3 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 PyObject * obj2 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "offset",(char *) "whence", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9246 }
9247 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 if (obj2) {
9254 ecode3 = SWIG_AsVal_int(obj2, &val3);
9255 if (!SWIG_IsOK(ecode3)) {
9256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9257 }
9258 arg3 = static_cast< int >(val3);
9259 }
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 (arg1)->seek(arg2,arg3);
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 resultobj = SWIG_Py_Void();
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9276 int result;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9286 }
9287 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (int)(arg1)->tell();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_From_int(static_cast< int >(result));
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9302 PyObject *resultobj = 0;
9303 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9304 char result;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9314 }
9315 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (char)(arg1)->Peek();
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_From_char(static_cast< char >(result));
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9332 char result;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 PyObject *swig_obj[1] ;
9336
9337 if (!args) SWIG_fail;
9338 swig_obj[0] = args;
9339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9342 }
9343 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (char)(arg1)->GetC();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_char(static_cast< char >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9360 size_t result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9370 }
9371 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (size_t)(arg1)->LastRead();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9386 PyObject *resultobj = 0;
9387 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9388 bool result;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 PyObject *swig_obj[1] ;
9392
9393 if (!args) SWIG_fail;
9394 swig_obj[0] = args;
9395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9396 if (!SWIG_IsOK(res1)) {
9397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9398 }
9399 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (bool)(arg1)->CanRead();
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9408 }
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 bool result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (bool)(arg1)->Eof();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9438 }
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9448 char arg2 ;
9449 bool result;
9450 void *argp1 = 0 ;
9451 int res1 = 0 ;
9452 char val2 ;
9453 int ecode2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "c", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9466 ecode2 = SWIG_AsVal_char(obj1, &val2);
9467 if (!SWIG_IsOK(ecode2)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9469 }
9470 arg2 = static_cast< char >(val2);
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (bool)(arg1)->Ungetch(arg2);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 {
9478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9479 }
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9487 PyObject *resultobj = 0;
9488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9489 long arg2 ;
9490 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9491 long result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 long val2 ;
9495 int ecode2 = 0 ;
9496 int val3 ;
9497 int ecode3 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 char * kwnames[] = {
9502 (char *) "self",(char *) "pos",(char *) "mode", NULL
9503 };
9504
9505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9507 if (!SWIG_IsOK(res1)) {
9508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9509 }
9510 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9511 ecode2 = SWIG_AsVal_long(obj1, &val2);
9512 if (!SWIG_IsOK(ecode2)) {
9513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9514 }
9515 arg2 = static_cast< long >(val2);
9516 if (obj2) {
9517 ecode3 = SWIG_AsVal_int(obj2, &val3);
9518 if (!SWIG_IsOK(ecode3)) {
9519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9520 }
9521 arg3 = static_cast< wxSeekMode >(val3);
9522 }
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (long)(arg1)->SeekI(arg2,arg3);
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_From_long(static_cast< long >(result));
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 PyObject *resultobj = 0;
9538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9539 long result;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 PyObject *swig_obj[1] ;
9543
9544 if (!args) SWIG_fail;
9545 swig_obj[0] = args;
9546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9547 if (!SWIG_IsOK(res1)) {
9548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9549 }
9550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (long)(arg1)->TellI();
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_From_long(static_cast< long >(result));
9558 return resultobj;
9559 fail:
9560 return NULL;
9561 }
9562
9563
9564 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9565 PyObject *obj;
9566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9567 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9568 return SWIG_Py_Void();
9569 }
9570
9571 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9572 return SWIG_Python_InitShadowInstance(args);
9573 }
9574
9575 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj = 0;
9577 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9578 PyObject *arg2 = (PyObject *) 0 ;
9579 void *argp1 = 0 ;
9580 int res1 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "obj", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9591 }
9592 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9593 arg2 = obj1;
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 wxOutputStream_write(arg1,arg2);
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_Py_Void();
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *resultobj = 0;
9609 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9610 size_t result;
9611 void *argp1 = 0 ;
9612 int res1 = 0 ;
9613 PyObject *swig_obj[1] ;
9614
9615 if (!args) SWIG_fail;
9616 swig_obj[0] = args;
9617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9620 }
9621 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9636 PyObject *obj;
9637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9638 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9639 return SWIG_Py_Void();
9640 }
9641
9642 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9643 PyObject *resultobj = 0;
9644 wxInputStream *arg1 = (wxInputStream *) 0 ;
9645 wxString *arg2 = 0 ;
9646 wxString *arg3 = 0 ;
9647 wxString *arg4 = 0 ;
9648 wxDateTime arg5 ;
9649 wxFSFile *result = 0 ;
9650 wxPyInputStream *temp1 ;
9651 bool temp2 = false ;
9652 bool temp3 = false ;
9653 bool temp4 = false ;
9654 void *argp5 ;
9655 int res5 = 0 ;
9656 PyObject * obj0 = 0 ;
9657 PyObject * obj1 = 0 ;
9658 PyObject * obj2 = 0 ;
9659 PyObject * obj3 = 0 ;
9660 PyObject * obj4 = 0 ;
9661 char * kwnames[] = {
9662 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9663 };
9664
9665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9666 {
9667 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9668 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9669 } else {
9670 PyErr_Clear(); // clear the failure of the wxPyConvert above
9671 arg1 = wxPyCBInputStream_create(obj0, true);
9672 if (arg1 == NULL) {
9673 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9674 SWIG_fail;
9675 }
9676 }
9677 }
9678 {
9679 arg2 = wxString_in_helper(obj1);
9680 if (arg2 == NULL) SWIG_fail;
9681 temp2 = true;
9682 }
9683 {
9684 arg3 = wxString_in_helper(obj2);
9685 if (arg3 == NULL) SWIG_fail;
9686 temp3 = true;
9687 }
9688 {
9689 arg4 = wxString_in_helper(obj3);
9690 if (arg4 == NULL) SWIG_fail;
9691 temp4 = true;
9692 }
9693 {
9694 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9695 if (!SWIG_IsOK(res5)) {
9696 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9697 }
9698 if (!argp5) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9700 } else {
9701 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9702 arg5 = *temp;
9703 if (SWIG_IsNewObj(res5)) delete temp;
9704 }
9705 }
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9713 {
9714 if (temp2)
9715 delete arg2;
9716 }
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 {
9722 if (temp4)
9723 delete arg4;
9724 }
9725 return resultobj;
9726 fail:
9727 {
9728 if (temp2)
9729 delete arg2;
9730 }
9731 {
9732 if (temp3)
9733 delete arg3;
9734 }
9735 {
9736 if (temp4)
9737 delete arg4;
9738 }
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxFSFile *arg1 = (wxFSFile *) 0 ;
9746 void *argp1 = 0 ;
9747 int res1 = 0 ;
9748 PyObject *swig_obj[1] ;
9749
9750 if (!args) SWIG_fail;
9751 swig_obj[0] = args;
9752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9753 if (!SWIG_IsOK(res1)) {
9754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9755 }
9756 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 delete arg1;
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_Py_Void();
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9772 PyObject *resultobj = 0;
9773 wxFSFile *arg1 = (wxFSFile *) 0 ;
9774 wxInputStream *result = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 PyObject *swig_obj[1] ;
9778
9779 if (!args) SWIG_fail;
9780 swig_obj[0] = args;
9781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9784 }
9785 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (wxInputStream *)(arg1)->GetStream();
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 {
9793 wxPyInputStream * _ptr = NULL;
9794
9795 if (result) {
9796 _ptr = new wxPyInputStream(result);
9797 }
9798 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 wxFSFile *arg1 = (wxFSFile *) 0 ;
9809 wxString *result = 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 PyObject *swig_obj[1] ;
9813
9814 if (!args) SWIG_fail;
9815 swig_obj[0] = args;
9816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9819 }
9820 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 {
9824 wxString const &_result_ref = (arg1)->GetMimeType();
9825 result = (wxString *) &_result_ref;
9826 }
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *resultobj = 0;
9845 wxFSFile *arg1 = (wxFSFile *) 0 ;
9846 wxString *result = 0 ;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 PyObject *swig_obj[1] ;
9850
9851 if (!args) SWIG_fail;
9852 swig_obj[0] = args;
9853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9856 }
9857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 {
9861 wxString const &_result_ref = (arg1)->GetLocation();
9862 result = (wxString *) &_result_ref;
9863 }
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 PyObject *resultobj = 0;
9882 wxFSFile *arg1 = (wxFSFile *) 0 ;
9883 wxString *result = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 PyObject *swig_obj[1] ;
9887
9888 if (!args) SWIG_fail;
9889 swig_obj[0] = args;
9890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9893 }
9894 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 {
9898 wxString const &_result_ref = (arg1)->GetAnchor();
9899 result = (wxString *) &_result_ref;
9900 }
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 #if wxUSE_UNICODE
9906 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9907 #else
9908 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9909 #endif
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxFSFile *arg1 = (wxFSFile *) 0 ;
9920 wxDateTime result;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9930 }
9931 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (arg1)->GetModificationTime();
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *obj;
9947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9948 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9949 return SWIG_Py_Void();
9950 }
9951
9952 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 return SWIG_Python_InitShadowInstance(args);
9954 }
9955
9956 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9957 PyObject *resultobj = 0;
9958 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject *swig_obj[1] ;
9962
9963 if (!args) SWIG_fail;
9964 swig_obj[0] = args;
9965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9968 }
9969 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 delete arg1;
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 resultobj = SWIG_Py_Void();
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *obj;
9986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9987 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9988 return SWIG_Py_Void();
9989 }
9990
9991 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9992 PyObject *resultobj = 0;
9993 wxPyFileSystemHandler *result = 0 ;
9994
9995 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10012 PyObject *arg2 = (PyObject *) 0 ;
10013 PyObject *arg3 = (PyObject *) 0 ;
10014 void *argp1 = 0 ;
10015 int res1 = 0 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 PyObject * obj2 = 0 ;
10019 char * kwnames[] = {
10020 (char *) "self",(char *) "self",(char *) "_class", NULL
10021 };
10022
10023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10029 arg2 = obj1;
10030 arg3 = obj2;
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 (arg1)->_setCallbackInfo(arg2,arg3);
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 resultobj = SWIG_Py_Void();
10038 return resultobj;
10039 fail:
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10047 wxString *arg2 = 0 ;
10048 bool result;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 bool temp2 = false ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "location", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10062 }
10063 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10064 {
10065 arg2 = wxString_in_helper(obj1);
10066 if (arg2 == NULL) SWIG_fail;
10067 temp2 = true;
10068 }
10069 {
10070 PyThreadState* __tstate = wxPyBeginAllowThreads();
10071 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 {
10076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10077 }
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10093 PyObject *resultobj = 0;
10094 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10095 wxFileSystem *arg2 = 0 ;
10096 wxString *arg3 = 0 ;
10097 wxFSFile *result = 0 ;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 void *argp2 = 0 ;
10101 int res2 = 0 ;
10102 bool temp3 = false ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 PyObject * obj2 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "fs",(char *) "location", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10117 if (!SWIG_IsOK(res2)) {
10118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10119 }
10120 if (!argp2) {
10121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10122 }
10123 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10124 {
10125 arg3 = wxString_in_helper(obj2);
10126 if (arg3 == NULL) SWIG_fail;
10127 temp3 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10137 }
10138 {
10139 if (temp3)
10140 delete arg3;
10141 }
10142 return resultobj;
10143 fail:
10144 {
10145 if (temp3)
10146 delete arg3;
10147 }
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj = 0;
10154 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 int arg3 = (int) 0 ;
10157 wxString result;
10158 void *argp1 = 0 ;
10159 int res1 = 0 ;
10160 bool temp2 = false ;
10161 int val3 ;
10162 int ecode3 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 PyObject * obj2 = 0 ;
10166 char * kwnames[] = {
10167 (char *) "self",(char *) "spec",(char *) "flags", NULL
10168 };
10169
10170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10174 }
10175 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10176 {
10177 arg2 = wxString_in_helper(obj1);
10178 if (arg2 == NULL) SWIG_fail;
10179 temp2 = true;
10180 }
10181 if (obj2) {
10182 ecode3 = SWIG_AsVal_int(obj2, &val3);
10183 if (!SWIG_IsOK(ecode3)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10185 }
10186 arg3 = static_cast< int >(val3);
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 #if wxUSE_UNICODE
10196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10197 #else
10198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10199 #endif
10200 }
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10216 PyObject *resultobj = 0;
10217 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10218 wxString result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 PyObject *swig_obj[1] ;
10222
10223 if (!args) SWIG_fail;
10224 swig_obj[0] = args;
10225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10228 }
10229 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (arg1)->FindNext();
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 {
10237 #if wxUSE_UNICODE
10238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10239 #else
10240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10241 #endif
10242 }
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10252 wxString *arg2 = 0 ;
10253 wxString result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "location", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->GetProtocol((wxString const &)*arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString *arg2 = 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "location", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 #if wxUSE_UNICODE
10334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10335 #else
10336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10337 #endif
10338 }
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = 0;
10355 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10356 wxString *arg2 = 0 ;
10357 wxString result;
10358 void *argp1 = 0 ;
10359 int res1 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char * kwnames[] = {
10364 (char *) "self",(char *) "location", NULL
10365 };
10366
10367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (arg1)->GetAnchor((wxString const &)*arg2);
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 #if wxUSE_UNICODE
10386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10387 #else
10388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10389 #endif
10390 }
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10408 wxString *arg2 = 0 ;
10409 wxString result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 bool temp2 = false ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "location", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 {
10437 #if wxUSE_UNICODE
10438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10439 #else
10440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10441 #endif
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10458 PyObject *resultobj = 0;
10459 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10460 wxString *arg2 = 0 ;
10461 wxString result;
10462 void *argp1 = 0 ;
10463 int res1 = 0 ;
10464 bool temp2 = false ;
10465 PyObject * obj0 = 0 ;
10466 PyObject * obj1 = 0 ;
10467 char * kwnames[] = {
10468 (char *) "self",(char *) "location", NULL
10469 };
10470
10471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10473 if (!SWIG_IsOK(res1)) {
10474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10475 }
10476 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10477 {
10478 arg2 = wxString_in_helper(obj1);
10479 if (arg2 == NULL) SWIG_fail;
10480 temp2 = true;
10481 }
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 {
10489 #if wxUSE_UNICODE
10490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10491 #else
10492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10493 #endif
10494 }
10495 {
10496 if (temp2)
10497 delete arg2;
10498 }
10499 return resultobj;
10500 fail:
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10510 PyObject *obj;
10511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10512 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10513 return SWIG_Py_Void();
10514 }
10515
10516 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10517 return SWIG_Python_InitShadowInstance(args);
10518 }
10519
10520 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxFileSystem *result = 0 ;
10523
10524 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (wxFileSystem *)new wxFileSystem();
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10533 }
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10552 }
10553 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 delete arg1;
10557
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10569 PyObject *resultobj = 0;
10570 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10571 wxString *arg2 = 0 ;
10572 bool arg3 = (bool) false ;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 bool temp2 = false ;
10576 bool val3 ;
10577 int ecode3 = 0 ;
10578 PyObject * obj0 = 0 ;
10579 PyObject * obj1 = 0 ;
10580 PyObject * obj2 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10589 }
10590 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 if (obj2) {
10597 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10598 if (!SWIG_IsOK(ecode3)) {
10599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10600 }
10601 arg3 = static_cast< bool >(val3);
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_Py_Void();
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return resultobj;
10615 fail:
10616 {
10617 if (temp2)
10618 delete arg2;
10619 }
10620 return NULL;
10621 }
10622
10623
10624 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10625 PyObject *resultobj = 0;
10626 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 PyObject *swig_obj[1] ;
10631
10632 if (!args) SWIG_fail;
10633 swig_obj[0] = args;
10634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10637 }
10638 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (arg1)->GetPath();
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 {
10646 #if wxUSE_UNICODE
10647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10648 #else
10649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10650 #endif
10651 }
10652 return resultobj;
10653 fail:
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10659 PyObject *resultobj = 0;
10660 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10661 wxString *arg2 = 0 ;
10662 wxFSFile *result = 0 ;
10663 void *argp1 = 0 ;
10664 int res1 = 0 ;
10665 bool temp2 = false ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "location", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 {
10690 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10691 }
10692 {
10693 if (temp2)
10694 delete arg2;
10695 }
10696 return resultobj;
10697 fail:
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10707 PyObject *resultobj = 0;
10708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10709 wxString *arg2 = 0 ;
10710 int arg3 = (int) 0 ;
10711 wxString result;
10712 void *argp1 = 0 ;
10713 int res1 = 0 ;
10714 bool temp2 = false ;
10715 int val3 ;
10716 int ecode3 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "spec",(char *) "flags", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10728 }
10729 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10730 {
10731 arg2 = wxString_in_helper(obj1);
10732 if (arg2 == NULL) SWIG_fail;
10733 temp2 = true;
10734 }
10735 if (obj2) {
10736 ecode3 = SWIG_AsVal_int(obj2, &val3);
10737 if (!SWIG_IsOK(ecode3)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10739 }
10740 arg3 = static_cast< int >(val3);
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 #if wxUSE_UNICODE
10750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10751 #else
10752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10753 #endif
10754 }
10755 {
10756 if (temp2)
10757 delete arg2;
10758 }
10759 return resultobj;
10760 fail:
10761 {
10762 if (temp2)
10763 delete arg2;
10764 }
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10770 PyObject *resultobj = 0;
10771 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10772 wxString result;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 PyObject *swig_obj[1] ;
10776
10777 if (!args) SWIG_fail;
10778 swig_obj[0] = args;
10779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10780 if (!SWIG_IsOK(res1)) {
10781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10782 }
10783 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (arg1)->FindNext();
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 #if wxUSE_UNICODE
10792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10793 #else
10794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10795 #endif
10796 }
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj = 0;
10805 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10806 int res1 = 0 ;
10807 PyObject * obj0 = 0 ;
10808 char * kwnames[] = {
10809 (char *) "handler", NULL
10810 };
10811
10812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10813 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10814 if (!SWIG_IsOK(res1)) {
10815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10816 }
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 wxFileSystem::AddHandler(arg1);
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_Py_Void();
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10831 PyObject *resultobj = 0;
10832
10833 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 wxFileSystem::CleanUpHandlers();
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxString *arg1 = 0 ;
10850 wxString result;
10851 bool temp1 = false ;
10852 PyObject * obj0 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "filename", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10858 {
10859 arg1 = wxString_in_helper(obj0);
10860 if (arg1 == NULL) SWIG_fail;
10861 temp1 = true;
10862 }
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 #if wxUSE_UNICODE
10871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10872 #else
10873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10874 #endif
10875 }
10876 {
10877 if (temp1)
10878 delete arg1;
10879 }
10880 return resultobj;
10881 fail:
10882 {
10883 if (temp1)
10884 delete arg1;
10885 }
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxString *arg1 = 0 ;
10893 wxString result;
10894 bool temp1 = false ;
10895 PyObject * obj0 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "url", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10901 {
10902 arg1 = wxString_in_helper(obj0);
10903 if (arg1 == NULL) SWIG_fail;
10904 temp1 = true;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 #if wxUSE_UNICODE
10914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10915 #else
10916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10917 #endif
10918 }
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934 PyObject *obj;
10935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10936 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10937 return SWIG_Py_Void();
10938 }
10939
10940 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10941 return SWIG_Python_InitShadowInstance(args);
10942 }
10943
10944 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 PyObject *resultobj = 0;
10946 wxInternetFSHandler *result = 0 ;
10947
10948 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10965 wxString *arg2 = 0 ;
10966 bool result;
10967 void *argp1 = 0 ;
10968 int res1 = 0 ;
10969 bool temp2 = false ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "location", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10980 }
10981 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10982 {
10983 arg2 = wxString_in_helper(obj1);
10984 if (arg2 == NULL) SWIG_fail;
10985 temp2 = true;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10990 wxPyEndAllowThreads(__tstate);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 {
10997 if (temp2)
10998 delete arg2;
10999 }
11000 return resultobj;
11001 fail:
11002 {
11003 if (temp2)
11004 delete arg2;
11005 }
11006 return NULL;
11007 }
11008
11009
11010 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj = 0;
11012 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11013 wxFileSystem *arg2 = 0 ;
11014 wxString *arg3 = 0 ;
11015 wxFSFile *result = 0 ;
11016 void *argp1 = 0 ;
11017 int res1 = 0 ;
11018 void *argp2 = 0 ;
11019 int res2 = 0 ;
11020 bool temp3 = false ;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 char * kwnames[] = {
11025 (char *) "self",(char *) "fs",(char *) "location", NULL
11026 };
11027
11028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11032 }
11033 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11040 }
11041 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11042 {
11043 arg3 = wxString_in_helper(obj2);
11044 if (arg3 == NULL) SWIG_fail;
11045 temp3 = true;
11046 }
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11055 }
11056 {
11057 if (temp3)
11058 delete arg3;
11059 }
11060 return resultobj;
11061 fail:
11062 {
11063 if (temp3)
11064 delete arg3;
11065 }
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11071 PyObject *obj;
11072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11073 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11074 return SWIG_Py_Void();
11075 }
11076
11077 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 return SWIG_Python_InitShadowInstance(args);
11079 }
11080
11081 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11082 PyObject *resultobj = 0;
11083 wxZipFSHandler *result = 0 ;
11084
11085 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (wxZipFSHandler *)new wxZipFSHandler();
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11102 wxString *arg2 = 0 ;
11103 bool result;
11104 void *argp1 = 0 ;
11105 int res1 = 0 ;
11106 bool temp2 = false ;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 char * kwnames[] = {
11110 (char *) "self",(char *) "location", NULL
11111 };
11112
11113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 {
11120 arg2 = wxString_in_helper(obj1);
11121 if (arg2 == NULL) SWIG_fail;
11122 temp2 = true;
11123 }
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 {
11131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11132 }
11133 {
11134 if (temp2)
11135 delete arg2;
11136 }
11137 return resultobj;
11138 fail:
11139 {
11140 if (temp2)
11141 delete arg2;
11142 }
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj = 0;
11149 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11150 wxFileSystem *arg2 = 0 ;
11151 wxString *arg3 = 0 ;
11152 wxFSFile *result = 0 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 void *argp2 = 0 ;
11156 int res2 = 0 ;
11157 bool temp3 = false ;
11158 PyObject * obj0 = 0 ;
11159 PyObject * obj1 = 0 ;
11160 PyObject * obj2 = 0 ;
11161 char * kwnames[] = {
11162 (char *) "self",(char *) "fs",(char *) "location", NULL
11163 };
11164
11165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11167 if (!SWIG_IsOK(res1)) {
11168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11169 }
11170 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11172 if (!SWIG_IsOK(res2)) {
11173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11174 }
11175 if (!argp2) {
11176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11177 }
11178 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11179 {
11180 arg3 = wxString_in_helper(obj2);
11181 if (arg3 == NULL) SWIG_fail;
11182 temp3 = true;
11183 }
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11192 }
11193 {
11194 if (temp3)
11195 delete arg3;
11196 }
11197 return resultobj;
11198 fail:
11199 {
11200 if (temp3)
11201 delete arg3;
11202 }
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj = 0;
11209 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11210 wxString *arg2 = 0 ;
11211 int arg3 = (int) 0 ;
11212 wxString result;
11213 void *argp1 = 0 ;
11214 int res1 = 0 ;
11215 bool temp2 = false ;
11216 int val3 ;
11217 int ecode3 = 0 ;
11218 PyObject * obj0 = 0 ;
11219 PyObject * obj1 = 0 ;
11220 PyObject * obj2 = 0 ;
11221 char * kwnames[] = {
11222 (char *) "self",(char *) "spec",(char *) "flags", NULL
11223 };
11224
11225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11227 if (!SWIG_IsOK(res1)) {
11228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11229 }
11230 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11231 {
11232 arg2 = wxString_in_helper(obj1);
11233 if (arg2 == NULL) SWIG_fail;
11234 temp2 = true;
11235 }
11236 if (obj2) {
11237 ecode3 = SWIG_AsVal_int(obj2, &val3);
11238 if (!SWIG_IsOK(ecode3)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11240 }
11241 arg3 = static_cast< int >(val3);
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 #if wxUSE_UNICODE
11251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11252 #else
11253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11254 #endif
11255 }
11256 {
11257 if (temp2)
11258 delete arg2;
11259 }
11260 return resultobj;
11261 fail:
11262 {
11263 if (temp2)
11264 delete arg2;
11265 }
11266 return NULL;
11267 }
11268
11269
11270 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11271 PyObject *resultobj = 0;
11272 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11273 wxString result;
11274 void *argp1 = 0 ;
11275 int res1 = 0 ;
11276 PyObject *swig_obj[1] ;
11277
11278 if (!args) SWIG_fail;
11279 swig_obj[0] = args;
11280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11281 if (!SWIG_IsOK(res1)) {
11282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11283 }
11284 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (arg1)->FindNext();
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 #if wxUSE_UNICODE
11293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11294 #else
11295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11296 #endif
11297 }
11298 return resultobj;
11299 fail:
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 PyObject *obj;
11306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11307 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11308 return SWIG_Py_Void();
11309 }
11310
11311 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11312 return SWIG_Python_InitShadowInstance(args);
11313 }
11314
11315 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj = 0;
11317 wxString *arg1 = 0 ;
11318 wxImage *arg2 = 0 ;
11319 long arg3 ;
11320 bool temp1 = false ;
11321 void *argp2 = 0 ;
11322 int res2 = 0 ;
11323 long val3 ;
11324 int ecode3 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "filename",(char *) "image",(char *) "type", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 {
11334 arg1 = wxString_in_helper(obj0);
11335 if (arg1 == NULL) SWIG_fail;
11336 temp1 = true;
11337 }
11338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11341 }
11342 if (!argp2) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11344 }
11345 arg2 = reinterpret_cast< wxImage * >(argp2);
11346 ecode3 = SWIG_AsVal_long(obj2, &val3);
11347 if (!SWIG_IsOK(ecode3)) {
11348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11349 }
11350 arg3 = static_cast< long >(val3);
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxString *arg1 = 0 ;
11375 wxBitmap *arg2 = 0 ;
11376 long arg3 ;
11377 bool temp1 = false ;
11378 void *argp2 = 0 ;
11379 int res2 = 0 ;
11380 long val3 ;
11381 int ecode3 = 0 ;
11382 PyObject * obj0 = 0 ;
11383 PyObject * obj1 = 0 ;
11384 PyObject * obj2 = 0 ;
11385 char * kwnames[] = {
11386 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11387 };
11388
11389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11390 {
11391 arg1 = wxString_in_helper(obj0);
11392 if (arg1 == NULL) SWIG_fail;
11393 temp1 = true;
11394 }
11395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11396 if (!SWIG_IsOK(res2)) {
11397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11398 }
11399 if (!argp2) {
11400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11401 }
11402 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11403 ecode3 = SWIG_AsVal_long(obj2, &val3);
11404 if (!SWIG_IsOK(ecode3)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11406 }
11407 arg3 = static_cast< long >(val3);
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 resultobj = SWIG_Py_Void();
11415 {
11416 if (temp1)
11417 delete arg1;
11418 }
11419 return resultobj;
11420 fail:
11421 {
11422 if (temp1)
11423 delete arg1;
11424 }
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 PyObject *arg2 = (PyObject *) 0 ;
11433 bool temp1 = false ;
11434 PyObject * obj0 = 0 ;
11435 PyObject * obj1 = 0 ;
11436 char * kwnames[] = {
11437 (char *) "filename",(char *) "data", NULL
11438 };
11439
11440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11441 {
11442 arg1 = wxString_in_helper(obj0);
11443 if (arg1 == NULL) SWIG_fail;
11444 temp1 = true;
11445 }
11446 arg2 = obj1;
11447 {
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 resultobj = SWIG_Py_Void();
11454 {
11455 if (temp1)
11456 delete arg1;
11457 }
11458 return resultobj;
11459 fail:
11460 {
11461 if (temp1)
11462 delete arg1;
11463 }
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 wxMemoryFSHandler *result = 0 ;
11471
11472 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj = 0;
11488 wxString *arg1 = 0 ;
11489 bool temp1 = false ;
11490 PyObject * obj0 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "filename", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11496 {
11497 arg1 = wxString_in_helper(obj0);
11498 if (arg1 == NULL) SWIG_fail;
11499 temp1 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 resultobj = SWIG_Py_Void();
11508 {
11509 if (temp1)
11510 delete arg1;
11511 }
11512 return resultobj;
11513 fail:
11514 {
11515 if (temp1)
11516 delete arg1;
11517 }
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11525 wxString *arg2 = 0 ;
11526 bool result;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 bool temp2 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 char * kwnames[] = {
11533 (char *) "self",(char *) "location", NULL
11534 };
11535
11536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 {
11543 arg2 = wxString_in_helper(obj1);
11544 if (arg2 == NULL) SWIG_fail;
11545 temp2 = true;
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 {
11557 if (temp2)
11558 delete arg2;
11559 }
11560 return resultobj;
11561 fail:
11562 {
11563 if (temp2)
11564 delete arg2;
11565 }
11566 return NULL;
11567 }
11568
11569
11570 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11571 PyObject *resultobj = 0;
11572 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11573 wxFileSystem *arg2 = 0 ;
11574 wxString *arg3 = 0 ;
11575 wxFSFile *result = 0 ;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 void *argp2 = 0 ;
11579 int res2 = 0 ;
11580 bool temp3 = false ;
11581 PyObject * obj0 = 0 ;
11582 PyObject * obj1 = 0 ;
11583 PyObject * obj2 = 0 ;
11584 char * kwnames[] = {
11585 (char *) "self",(char *) "fs",(char *) "location", NULL
11586 };
11587
11588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11592 }
11593 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11595 if (!SWIG_IsOK(res2)) {
11596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11597 }
11598 if (!argp2) {
11599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11600 }
11601 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11602 {
11603 arg3 = wxString_in_helper(obj2);
11604 if (arg3 == NULL) SWIG_fail;
11605 temp3 = true;
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11615 }
11616 {
11617 if (temp3)
11618 delete arg3;
11619 }
11620 return resultobj;
11621 fail:
11622 {
11623 if (temp3)
11624 delete arg3;
11625 }
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj = 0;
11632 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11633 wxString *arg2 = 0 ;
11634 int arg3 = (int) 0 ;
11635 wxString result;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 bool temp2 = false ;
11639 int val3 ;
11640 int ecode3 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 PyObject * obj2 = 0 ;
11644 char * kwnames[] = {
11645 (char *) "self",(char *) "spec",(char *) "flags", NULL
11646 };
11647
11648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11652 }
11653 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11654 {
11655 arg2 = wxString_in_helper(obj1);
11656 if (arg2 == NULL) SWIG_fail;
11657 temp2 = true;
11658 }
11659 if (obj2) {
11660 ecode3 = SWIG_AsVal_int(obj2, &val3);
11661 if (!SWIG_IsOK(ecode3)) {
11662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11663 }
11664 arg3 = static_cast< int >(val3);
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 #if wxUSE_UNICODE
11674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11675 #else
11676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11677 #endif
11678 }
11679 {
11680 if (temp2)
11681 delete arg2;
11682 }
11683 return resultobj;
11684 fail:
11685 {
11686 if (temp2)
11687 delete arg2;
11688 }
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11696 wxString result;
11697 void *argp1 = 0 ;
11698 int res1 = 0 ;
11699 PyObject *swig_obj[1] ;
11700
11701 if (!args) SWIG_fail;
11702 swig_obj[0] = args;
11703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11706 }
11707 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (arg1)->FindNext();
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 #if wxUSE_UNICODE
11716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11717 #else
11718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11719 #endif
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11728 PyObject *obj;
11729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11730 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11731 return SWIG_Py_Void();
11732 }
11733
11734 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 return SWIG_Python_InitShadowInstance(args);
11736 }
11737
11738 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11741 wxString result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11751 }
11752 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (arg1)->GetName();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 #if wxUSE_UNICODE
11761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11762 #else
11763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11764 #endif
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11773 PyObject *resultobj = 0;
11774 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11775 wxString result;
11776 void *argp1 = 0 ;
11777 int res1 = 0 ;
11778 PyObject *swig_obj[1] ;
11779
11780 if (!args) SWIG_fail;
11781 swig_obj[0] = args;
11782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11783 if (!SWIG_IsOK(res1)) {
11784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11785 }
11786 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (arg1)->GetExtension();
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 {
11794 #if wxUSE_UNICODE
11795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11796 #else
11797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11798 #endif
11799 }
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11809 long result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11819 }
11820 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (long)(arg1)->GetType();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_long(static_cast< long >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11837 wxString result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11847 }
11848 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (arg1)->GetMimeType();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 #if wxUSE_UNICODE
11857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11858 #else
11859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11860 #endif
11861 }
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11871 wxString *arg2 = 0 ;
11872 bool result;
11873 void *argp1 = 0 ;
11874 int res1 = 0 ;
11875 bool temp2 = false ;
11876 PyObject * obj0 = 0 ;
11877 PyObject * obj1 = 0 ;
11878 char * kwnames[] = {
11879 (char *) "self",(char *) "name", NULL
11880 };
11881
11882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11886 }
11887 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11888 {
11889 arg2 = wxString_in_helper(obj1);
11890 if (arg2 == NULL) SWIG_fail;
11891 temp2 = true;
11892 }
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 {
11900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11901 }
11902 {
11903 if (temp2)
11904 delete arg2;
11905 }
11906 return resultobj;
11907 fail:
11908 {
11909 if (temp2)
11910 delete arg2;
11911 }
11912 return NULL;
11913 }
11914
11915
11916 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj = 0;
11918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11919 wxInputStream *arg2 = 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 wxPyInputStream *temp2 ;
11924 bool created2 ;
11925 PyObject * obj0 = 0 ;
11926 PyObject * obj1 = 0 ;
11927 char * kwnames[] = {
11928 (char *) "self",(char *) "stream", NULL
11929 };
11930
11931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11939 arg2 = temp2->m_wxis;
11940 created2 = false;
11941 } else {
11942 PyErr_Clear(); // clear the failure of the wxPyConvert above
11943 arg2 = wxPyCBInputStream_create(obj1, false);
11944 if (arg2 == NULL) {
11945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11946 SWIG_fail;
11947 }
11948 created2 = true;
11949 }
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead(*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (created2) delete arg2;
11962 }
11963 return resultobj;
11964 fail:
11965 {
11966 if (created2) delete arg2;
11967 }
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj = 0;
11974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11975 wxString *arg2 = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 bool temp2 = false ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 char * kwnames[] = {
11982 (char *) "self",(char *) "name", NULL
11983 };
11984
11985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11989 }
11990 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11991 {
11992 arg2 = wxString_in_helper(obj1);
11993 if (arg2 == NULL) SWIG_fail;
11994 temp2 = true;
11995 }
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 (arg1)->SetName((wxString const &)*arg2);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_Py_Void();
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12020 wxString *arg2 = 0 ;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 bool temp2 = false ;
12024 PyObject * obj0 = 0 ;
12025 PyObject * obj1 = 0 ;
12026 char * kwnames[] = {
12027 (char *) "self",(char *) "extension", NULL
12028 };
12029
12030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12032 if (!SWIG_IsOK(res1)) {
12033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12034 }
12035 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12036 {
12037 arg2 = wxString_in_helper(obj1);
12038 if (arg2 == NULL) SWIG_fail;
12039 temp2 = true;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 (arg1)->SetExtension((wxString const &)*arg2);
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 resultobj = SWIG_Py_Void();
12048 {
12049 if (temp2)
12050 delete arg2;
12051 }
12052 return resultobj;
12053 fail:
12054 {
12055 if (temp2)
12056 delete arg2;
12057 }
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12063 PyObject *resultobj = 0;
12064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12065 long arg2 ;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 long val2 ;
12069 int ecode2 = 0 ;
12070 PyObject * obj0 = 0 ;
12071 PyObject * obj1 = 0 ;
12072 char * kwnames[] = {
12073 (char *) "self",(char *) "type", NULL
12074 };
12075
12076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12080 }
12081 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12082 ecode2 = SWIG_AsVal_long(obj1, &val2);
12083 if (!SWIG_IsOK(ecode2)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12085 }
12086 arg2 = static_cast< long >(val2);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 (arg1)->SetType(arg2);
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_Py_Void();
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj = 0;
12102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12103 wxString *arg2 = 0 ;
12104 void *argp1 = 0 ;
12105 int res1 = 0 ;
12106 bool temp2 = false ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 char * kwnames[] = {
12110 (char *) "self",(char *) "mimetype", NULL
12111 };
12112
12113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12117 }
12118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12119 {
12120 arg2 = wxString_in_helper(obj1);
12121 if (arg2 == NULL) SWIG_fail;
12122 temp2 = true;
12123 }
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 (arg1)->SetMimeType((wxString const &)*arg2);
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 resultobj = SWIG_Py_Void();
12131 {
12132 if (temp2)
12133 delete arg2;
12134 }
12135 return resultobj;
12136 fail:
12137 {
12138 if (temp2)
12139 delete arg2;
12140 }
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *obj;
12147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12148 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12149 return SWIG_Py_Void();
12150 }
12151
12152 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *resultobj = 0;
12154 wxPyImageHandler *result = 0 ;
12155
12156 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (wxPyImageHandler *)new wxPyImageHandler();
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj = 0;
12172 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12173 PyObject *arg2 = (PyObject *) 0 ;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "self", NULL
12180 };
12181
12182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12186 }
12187 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12188 arg2 = obj1;
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 (arg1)->_SetSelf(arg2);
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_Py_Void();
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *obj;
12204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12205 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12206 return SWIG_Py_Void();
12207 }
12208
12209 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 return SWIG_Python_InitShadowInstance(args);
12211 }
12212
12213 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12214 PyObject *resultobj = 0;
12215 wxImageHistogram *result = 0 ;
12216
12217 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (wxImageHistogram *)new wxImageHistogram();
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 byte arg1 ;
12234 byte arg2 ;
12235 byte arg3 ;
12236 unsigned long result;
12237 unsigned char val1 ;
12238 int ecode1 = 0 ;
12239 unsigned char val2 ;
12240 int ecode2 = 0 ;
12241 unsigned char val3 ;
12242 int ecode3 = 0 ;
12243 PyObject * obj0 = 0 ;
12244 PyObject * obj1 = 0 ;
12245 PyObject * obj2 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "r",(char *) "g",(char *) "b", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12251 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12252 if (!SWIG_IsOK(ecode1)) {
12253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12254 }
12255 arg1 = static_cast< byte >(val1);
12256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12257 if (!SWIG_IsOK(ecode2)) {
12258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12259 }
12260 arg2 = static_cast< byte >(val2);
12261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12262 if (!SWIG_IsOK(ecode3)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12264 }
12265 arg3 = static_cast< byte >(val3);
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj = 0;
12281 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12282 byte *arg2 = (byte *) 0 ;
12283 byte *arg3 = (byte *) 0 ;
12284 byte *arg4 = (byte *) 0 ;
12285 byte arg5 = (byte) 1 ;
12286 byte arg6 = (byte) 0 ;
12287 byte arg7 = (byte) 0 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 byte temp2 ;
12292 int res2 = SWIG_TMPOBJ ;
12293 byte temp3 ;
12294 int res3 = SWIG_TMPOBJ ;
12295 byte temp4 ;
12296 int res4 = SWIG_TMPOBJ ;
12297 unsigned char val5 ;
12298 int ecode5 = 0 ;
12299 unsigned char val6 ;
12300 int ecode6 = 0 ;
12301 unsigned char val7 ;
12302 int ecode7 = 0 ;
12303 PyObject * obj0 = 0 ;
12304 PyObject * obj1 = 0 ;
12305 PyObject * obj2 = 0 ;
12306 PyObject * obj3 = 0 ;
12307 char * kwnames[] = {
12308 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12309 };
12310
12311 arg2 = &temp2;
12312 arg3 = &temp3;
12313 arg4 = &temp4;
12314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12316 if (!SWIG_IsOK(res1)) {
12317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12318 }
12319 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12320 if (obj1) {
12321 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12322 if (!SWIG_IsOK(ecode5)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12324 }
12325 arg5 = static_cast< byte >(val5);
12326 }
12327 if (obj2) {
12328 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12329 if (!SWIG_IsOK(ecode6)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12331 }
12332 arg6 = static_cast< byte >(val6);
12333 }
12334 if (obj3) {
12335 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12336 if (!SWIG_IsOK(ecode7)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12338 }
12339 arg7 = static_cast< byte >(val7);
12340 }
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12349 }
12350 if (SWIG_IsTmpObj(res2)) {
12351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12352 } else {
12353 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12355 }
12356 if (SWIG_IsTmpObj(res3)) {
12357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12358 } else {
12359 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12361 }
12362 if (SWIG_IsTmpObj(res4)) {
12363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12364 } else {
12365 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj = 0;
12376 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12377 unsigned long arg2 ;
12378 unsigned long result;
12379 void *argp1 = 0 ;
12380 int res1 = 0 ;
12381 unsigned long val2 ;
12382 int ecode2 = 0 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "self",(char *) "key", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12395 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12398 }
12399 arg2 = static_cast< unsigned long >(val2);
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12416 byte arg2 ;
12417 byte arg3 ;
12418 byte arg4 ;
12419 unsigned long result;
12420 void *argp1 = 0 ;
12421 int res1 = 0 ;
12422 unsigned char val2 ;
12423 int ecode2 = 0 ;
12424 unsigned char val3 ;
12425 int ecode3 = 0 ;
12426 unsigned char val4 ;
12427 int ecode4 = 0 ;
12428 PyObject * obj0 = 0 ;
12429 PyObject * obj1 = 0 ;
12430 PyObject * obj2 = 0 ;
12431 PyObject * obj3 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12440 }
12441 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12442 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12443 if (!SWIG_IsOK(ecode2)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12445 }
12446 arg2 = static_cast< byte >(val2);
12447 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12448 if (!SWIG_IsOK(ecode3)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12450 }
12451 arg3 = static_cast< byte >(val3);
12452 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12453 if (!SWIG_IsOK(ecode4)) {
12454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12455 }
12456 arg4 = static_cast< byte >(val4);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = 0;
12472 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12473 wxColour *arg2 = 0 ;
12474 unsigned long result;
12475 void *argp1 = 0 ;
12476 int res1 = 0 ;
12477 wxColour temp2 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char * kwnames[] = {
12481 (char *) "self",(char *) "colour", NULL
12482 };
12483
12484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12488 }
12489 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12490 {
12491 arg2 = &temp2;
12492 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12493 }
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508 PyObject *obj;
12509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12510 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12511 return SWIG_Py_Void();
12512 }
12513
12514 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 return SWIG_Python_InitShadowInstance(args);
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 byte arg1 = (byte) 0 ;
12521 byte arg2 = (byte) 0 ;
12522 byte arg3 = (byte) 0 ;
12523 wxImage_RGBValue *result = 0 ;
12524 unsigned char val1 ;
12525 int ecode1 = 0 ;
12526 unsigned char val2 ;
12527 int ecode2 = 0 ;
12528 unsigned char val3 ;
12529 int ecode3 = 0 ;
12530 PyObject * obj0 = 0 ;
12531 PyObject * obj1 = 0 ;
12532 PyObject * obj2 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "r",(char *) "g",(char *) "b", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12538 if (obj0) {
12539 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12540 if (!SWIG_IsOK(ecode1)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12542 }
12543 arg1 = static_cast< byte >(val1);
12544 }
12545 if (obj1) {
12546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12547 if (!SWIG_IsOK(ecode2)) {
12548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12549 }
12550 arg2 = static_cast< byte >(val2);
12551 }
12552 if (obj2) {
12553 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12554 if (!SWIG_IsOK(ecode3)) {
12555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12556 }
12557 arg3 = static_cast< byte >(val3);
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 PyObject *resultobj = 0;
12574 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12575 byte arg2 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 unsigned char val2 ;
12579 int ecode2 = 0 ;
12580 PyObject *swig_obj[2] ;
12581
12582 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12584 if (!SWIG_IsOK(res1)) {
12585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12586 }
12587 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12588 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12589 if (!SWIG_IsOK(ecode2)) {
12590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12591 }
12592 arg2 = static_cast< byte >(val2);
12593 if (arg1) (arg1)->red = arg2;
12594
12595 resultobj = SWIG_Py_Void();
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12603 PyObject *resultobj = 0;
12604 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12605 byte result;
12606 void *argp1 = 0 ;
12607 int res1 = 0 ;
12608 PyObject *swig_obj[1] ;
12609
12610 if (!args) SWIG_fail;
12611 swig_obj[0] = args;
12612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12613 if (!SWIG_IsOK(res1)) {
12614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12615 }
12616 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12617 result = (byte) ((arg1)->red);
12618 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12619 return resultobj;
12620 fail:
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12628 byte arg2 ;
12629 void *argp1 = 0 ;
12630 int res1 = 0 ;
12631 unsigned char val2 ;
12632 int ecode2 = 0 ;
12633 PyObject *swig_obj[2] ;
12634
12635 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12637 if (!SWIG_IsOK(res1)) {
12638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12639 }
12640 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12641 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12644 }
12645 arg2 = static_cast< byte >(val2);
12646 if (arg1) (arg1)->green = arg2;
12647
12648 resultobj = SWIG_Py_Void();
12649 return resultobj;
12650 fail:
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656 PyObject *resultobj = 0;
12657 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12658 byte result;
12659 void *argp1 = 0 ;
12660 int res1 = 0 ;
12661 PyObject *swig_obj[1] ;
12662
12663 if (!args) SWIG_fail;
12664 swig_obj[0] = args;
12665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12666 if (!SWIG_IsOK(res1)) {
12667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12668 }
12669 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12670 result = (byte) ((arg1)->green);
12671 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679 PyObject *resultobj = 0;
12680 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12681 byte arg2 ;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 unsigned char val2 ;
12685 int ecode2 = 0 ;
12686 PyObject *swig_obj[2] ;
12687
12688 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12690 if (!SWIG_IsOK(res1)) {
12691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12692 }
12693 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12694 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12695 if (!SWIG_IsOK(ecode2)) {
12696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12697 }
12698 arg2 = static_cast< byte >(val2);
12699 if (arg1) (arg1)->blue = arg2;
12700
12701 resultobj = SWIG_Py_Void();
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 PyObject *resultobj = 0;
12710 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12711 byte result;
12712 void *argp1 = 0 ;
12713 int res1 = 0 ;
12714 PyObject *swig_obj[1] ;
12715
12716 if (!args) SWIG_fail;
12717 swig_obj[0] = args;
12718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12721 }
12722 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12723 result = (byte) ((arg1)->blue);
12724 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *obj;
12733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12734 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12735 return SWIG_Py_Void();
12736 }
12737
12738 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739 return SWIG_Python_InitShadowInstance(args);
12740 }
12741
12742 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 double arg1 = (double) 0.0 ;
12745 double arg2 = (double) 0.0 ;
12746 double arg3 = (double) 0.0 ;
12747 wxImage_HSVValue *result = 0 ;
12748 double val1 ;
12749 int ecode1 = 0 ;
12750 double val2 ;
12751 int ecode2 = 0 ;
12752 double val3 ;
12753 int ecode3 = 0 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 PyObject * obj2 = 0 ;
12757 char * kwnames[] = {
12758 (char *) "h",(char *) "s",(char *) "v", NULL
12759 };
12760
12761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12762 if (obj0) {
12763 ecode1 = SWIG_AsVal_double(obj0, &val1);
12764 if (!SWIG_IsOK(ecode1)) {
12765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12766 }
12767 arg1 = static_cast< double >(val1);
12768 }
12769 if (obj1) {
12770 ecode2 = SWIG_AsVal_double(obj1, &val2);
12771 if (!SWIG_IsOK(ecode2)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12773 }
12774 arg2 = static_cast< double >(val2);
12775 }
12776 if (obj2) {
12777 ecode3 = SWIG_AsVal_double(obj2, &val3);
12778 if (!SWIG_IsOK(ecode3)) {
12779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12780 }
12781 arg3 = static_cast< double >(val3);
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 PyObject *resultobj = 0;
12798 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12799 double arg2 ;
12800 void *argp1 = 0 ;
12801 int res1 = 0 ;
12802 double val2 ;
12803 int ecode2 = 0 ;
12804 PyObject *swig_obj[2] ;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12810 }
12811 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12812 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12813 if (!SWIG_IsOK(ecode2)) {
12814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12815 }
12816 arg2 = static_cast< double >(val2);
12817 if (arg1) (arg1)->hue = arg2;
12818
12819 resultobj = SWIG_Py_Void();
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 PyObject *resultobj = 0;
12828 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12829 double result;
12830 void *argp1 = 0 ;
12831 int res1 = 0 ;
12832 PyObject *swig_obj[1] ;
12833
12834 if (!args) SWIG_fail;
12835 swig_obj[0] = args;
12836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12837 if (!SWIG_IsOK(res1)) {
12838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12839 }
12840 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12841 result = (double) ((arg1)->hue);
12842 resultobj = SWIG_From_double(static_cast< double >(result));
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *resultobj = 0;
12851 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12852 double arg2 ;
12853 void *argp1 = 0 ;
12854 int res1 = 0 ;
12855 double val2 ;
12856 int ecode2 = 0 ;
12857 PyObject *swig_obj[2] ;
12858
12859 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12863 }
12864 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12865 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12866 if (!SWIG_IsOK(ecode2)) {
12867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12868 }
12869 arg2 = static_cast< double >(val2);
12870 if (arg1) (arg1)->saturation = arg2;
12871
12872 resultobj = SWIG_Py_Void();
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 PyObject *resultobj = 0;
12881 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12882 double result;
12883 void *argp1 = 0 ;
12884 int res1 = 0 ;
12885 PyObject *swig_obj[1] ;
12886
12887 if (!args) SWIG_fail;
12888 swig_obj[0] = args;
12889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12890 if (!SWIG_IsOK(res1)) {
12891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12892 }
12893 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12894 result = (double) ((arg1)->saturation);
12895 resultobj = SWIG_From_double(static_cast< double >(result));
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12905 double arg2 ;
12906 void *argp1 = 0 ;
12907 int res1 = 0 ;
12908 double val2 ;
12909 int ecode2 = 0 ;
12910 PyObject *swig_obj[2] ;
12911
12912 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12916 }
12917 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12918 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12919 if (!SWIG_IsOK(ecode2)) {
12920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12921 }
12922 arg2 = static_cast< double >(val2);
12923 if (arg1) (arg1)->value = arg2;
12924
12925 resultobj = SWIG_Py_Void();
12926 return resultobj;
12927 fail:
12928 return NULL;
12929 }
12930
12931
12932 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12933 PyObject *resultobj = 0;
12934 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12935 double result;
12936 void *argp1 = 0 ;
12937 int res1 = 0 ;
12938 PyObject *swig_obj[1] ;
12939
12940 if (!args) SWIG_fail;
12941 swig_obj[0] = args;
12942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12943 if (!SWIG_IsOK(res1)) {
12944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12945 }
12946 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12947 result = (double) ((arg1)->value);
12948 resultobj = SWIG_From_double(static_cast< double >(result));
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12956 PyObject *obj;
12957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12958 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12959 return SWIG_Py_Void();
12960 }
12961
12962 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 return SWIG_Python_InitShadowInstance(args);
12964 }
12965
12966 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj = 0;
12968 wxString *arg1 = 0 ;
12969 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12970 int arg3 = (int) -1 ;
12971 wxImage *result = 0 ;
12972 bool temp1 = false ;
12973 long val2 ;
12974 int ecode2 = 0 ;
12975 int val3 ;
12976 int ecode3 = 0 ;
12977 PyObject * obj0 = 0 ;
12978 PyObject * obj1 = 0 ;
12979 PyObject * obj2 = 0 ;
12980 char * kwnames[] = {
12981 (char *) "name",(char *) "type",(char *) "index", NULL
12982 };
12983
12984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12985 {
12986 arg1 = wxString_in_helper(obj0);
12987 if (arg1 == NULL) SWIG_fail;
12988 temp1 = true;
12989 }
12990 if (obj1) {
12991 ecode2 = SWIG_AsVal_long(obj1, &val2);
12992 if (!SWIG_IsOK(ecode2)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12994 }
12995 arg2 = static_cast< long >(val2);
12996 }
12997 if (obj2) {
12998 ecode3 = SWIG_AsVal_int(obj2, &val3);
12999 if (!SWIG_IsOK(ecode3)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13001 }
13002 arg3 = static_cast< int >(val3);
13003 }
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13011 {
13012 if (temp1)
13013 delete arg1;
13014 }
13015 return resultobj;
13016 fail:
13017 {
13018 if (temp1)
13019 delete arg1;
13020 }
13021 return NULL;
13022 }
13023
13024
13025 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026 PyObject *resultobj = 0;
13027 wxImage *arg1 = (wxImage *) 0 ;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 PyObject *swig_obj[1] ;
13031
13032 if (!args) SWIG_fail;
13033 swig_obj[0] = args;
13034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13037 }
13038 arg1 = reinterpret_cast< wxImage * >(argp1);
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 delete arg1;
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_Py_Void();
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj = 0;
13055 wxString *arg1 = 0 ;
13056 wxString *arg2 = 0 ;
13057 int arg3 = (int) -1 ;
13058 wxImage *result = 0 ;
13059 bool temp1 = false ;
13060 bool temp2 = false ;
13061 int val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 {
13072 arg1 = wxString_in_helper(obj0);
13073 if (arg1 == NULL) SWIG_fail;
13074 temp1 = true;
13075 }
13076 {
13077 arg2 = wxString_in_helper(obj1);
13078 if (arg2 == NULL) SWIG_fail;
13079 temp2 = true;
13080 }
13081 if (obj2) {
13082 ecode3 = SWIG_AsVal_int(obj2, &val3);
13083 if (!SWIG_IsOK(ecode3)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13085 }
13086 arg3 = static_cast< int >(val3);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13095 {
13096 if (temp1)
13097 delete arg1;
13098 }
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104 fail:
13105 {
13106 if (temp1)
13107 delete arg1;
13108 }
13109 {
13110 if (temp2)
13111 delete arg2;
13112 }
13113 return NULL;
13114 }
13115
13116
13117 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = 0;
13119 wxInputStream *arg1 = 0 ;
13120 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13121 int arg3 = (int) -1 ;
13122 wxImage *result = 0 ;
13123 wxPyInputStream *temp1 ;
13124 bool created1 ;
13125 long val2 ;
13126 int ecode2 = 0 ;
13127 int val3 ;
13128 int ecode3 = 0 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13131 PyObject * obj2 = 0 ;
13132 char * kwnames[] = {
13133 (char *) "stream",(char *) "type",(char *) "index", NULL
13134 };
13135
13136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13137 {
13138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13139 arg1 = temp1->m_wxis;
13140 created1 = false;
13141 } else {
13142 PyErr_Clear(); // clear the failure of the wxPyConvert above
13143 arg1 = wxPyCBInputStream_create(obj0, false);
13144 if (arg1 == NULL) {
13145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13146 SWIG_fail;
13147 }
13148 created1 = true;
13149 }
13150 }
13151 if (obj1) {
13152 ecode2 = SWIG_AsVal_long(obj1, &val2);
13153 if (!SWIG_IsOK(ecode2)) {
13154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13155 }
13156 arg2 = static_cast< long >(val2);
13157 }
13158 if (obj2) {
13159 ecode3 = SWIG_AsVal_int(obj2, &val3);
13160 if (!SWIG_IsOK(ecode3)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13162 }
13163 arg3 = static_cast< int >(val3);
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13172 {
13173 if (created1) delete arg1;
13174 }
13175 return resultobj;
13176 fail:
13177 {
13178 if (created1) delete arg1;
13179 }
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj = 0;
13186 wxInputStream *arg1 = 0 ;
13187 wxString *arg2 = 0 ;
13188 int arg3 = (int) -1 ;
13189 wxImage *result = 0 ;
13190 wxPyInputStream *temp1 ;
13191 bool created1 ;
13192 bool temp2 = false ;
13193 int val3 ;
13194 int ecode3 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 PyObject * obj2 = 0 ;
13198 char * kwnames[] = {
13199 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13200 };
13201
13202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13203 {
13204 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13205 arg1 = temp1->m_wxis;
13206 created1 = false;
13207 } else {
13208 PyErr_Clear(); // clear the failure of the wxPyConvert above
13209 arg1 = wxPyCBInputStream_create(obj0, false);
13210 if (arg1 == NULL) {
13211 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13212 SWIG_fail;
13213 }
13214 created1 = true;
13215 }
13216 }
13217 {
13218 arg2 = wxString_in_helper(obj1);
13219 if (arg2 == NULL) SWIG_fail;
13220 temp2 = true;
13221 }
13222 if (obj2) {
13223 ecode3 = SWIG_AsVal_int(obj2, &val3);
13224 if (!SWIG_IsOK(ecode3)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13226 }
13227 arg3 = static_cast< int >(val3);
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13236 {
13237 if (created1) delete arg1;
13238 }
13239 {
13240 if (temp2)
13241 delete arg2;
13242 }
13243 return resultobj;
13244 fail:
13245 {
13246 if (created1) delete arg1;
13247 }
13248 {
13249 if (temp2)
13250 delete arg2;
13251 }
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 int arg1 = (int) 0 ;
13259 int arg2 = (int) 0 ;
13260 bool arg3 = (bool) true ;
13261 wxImage *result = 0 ;
13262 int val1 ;
13263 int ecode1 = 0 ;
13264 int val2 ;
13265 int ecode2 = 0 ;
13266 bool val3 ;
13267 int ecode3 = 0 ;
13268 PyObject * obj0 = 0 ;
13269 PyObject * obj1 = 0 ;
13270 PyObject * obj2 = 0 ;
13271 char * kwnames[] = {
13272 (char *) "width",(char *) "height",(char *) "clear", NULL
13273 };
13274
13275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13276 if (obj0) {
13277 ecode1 = SWIG_AsVal_int(obj0, &val1);
13278 if (!SWIG_IsOK(ecode1)) {
13279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13280 }
13281 arg1 = static_cast< int >(val1);
13282 }
13283 if (obj1) {
13284 ecode2 = SWIG_AsVal_int(obj1, &val2);
13285 if (!SWIG_IsOK(ecode2)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13287 }
13288 arg2 = static_cast< int >(val2);
13289 }
13290 if (obj2) {
13291 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13292 if (!SWIG_IsOK(ecode3)) {
13293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13294 }
13295 arg3 = static_cast< bool >(val3);
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxBitmap *arg1 = 0 ;
13313 wxImage *result = 0 ;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 PyObject * obj0 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "bitmap", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13322 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13325 }
13326 if (!argp1) {
13327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13328 }
13329 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13330 {
13331 if (!wxPyCheckForApp()) SWIG_fail;
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj = 0;
13346 int arg1 ;
13347 int arg2 ;
13348 buffer arg3 ;
13349 int arg4 ;
13350 wxImage *result = 0 ;
13351 int val1 ;
13352 int ecode1 = 0 ;
13353 int val2 ;
13354 int ecode2 = 0 ;
13355 PyObject * obj0 = 0 ;
13356 PyObject * obj1 = 0 ;
13357 PyObject * obj2 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "width",(char *) "height",(char *) "data", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13363 ecode1 = SWIG_AsVal_int(obj0, &val1);
13364 if (!SWIG_IsOK(ecode1)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13366 }
13367 arg1 = static_cast< int >(val1);
13368 ecode2 = SWIG_AsVal_int(obj1, &val2);
13369 if (!SWIG_IsOK(ecode2)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13371 }
13372 arg2 = static_cast< int >(val2);
13373 {
13374 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj = 0;
13391 int arg1 ;
13392 int arg2 ;
13393 buffer arg3 ;
13394 int arg4 ;
13395 buffer arg5 ;
13396 int arg6 ;
13397 wxImage *result = 0 ;
13398 int val1 ;
13399 int ecode1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 PyObject * obj0 = 0 ;
13403 PyObject * obj1 = 0 ;
13404 PyObject * obj2 = 0 ;
13405 PyObject * obj3 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13411 ecode1 = SWIG_AsVal_int(obj0, &val1);
13412 if (!SWIG_IsOK(ecode1)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13414 }
13415 arg1 = static_cast< int >(val1);
13416 ecode2 = SWIG_AsVal_int(obj1, &val2);
13417 if (!SWIG_IsOK(ecode2)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13419 }
13420 arg2 = static_cast< int >(val2);
13421 {
13422 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13423 }
13424 {
13425 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13426 }
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj = 0;
13442 wxImage *arg1 = (wxImage *) 0 ;
13443 int arg2 ;
13444 int arg3 ;
13445 bool arg4 = (bool) true ;
13446 void *argp1 = 0 ;
13447 int res1 = 0 ;
13448 int val2 ;
13449 int ecode2 = 0 ;
13450 int val3 ;
13451 int ecode3 = 0 ;
13452 bool val4 ;
13453 int ecode4 = 0 ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 PyObject * obj2 = 0 ;
13457 PyObject * obj3 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13466 }
13467 arg1 = reinterpret_cast< wxImage * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 ecode3 = SWIG_AsVal_int(obj2, &val3);
13474 if (!SWIG_IsOK(ecode3)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13476 }
13477 arg3 = static_cast< int >(val3);
13478 if (obj3) {
13479 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13480 if (!SWIG_IsOK(ecode4)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13482 }
13483 arg4 = static_cast< bool >(val4);
13484 }
13485 {
13486 PyThreadState* __tstate = wxPyBeginAllowThreads();
13487 (arg1)->Create(arg2,arg3,arg4);
13488 wxPyEndAllowThreads(__tstate);
13489 if (PyErr_Occurred()) SWIG_fail;
13490 }
13491 resultobj = SWIG_Py_Void();
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxImage *arg1 = (wxImage *) 0 ;
13501 void *argp1 = 0 ;
13502 int res1 = 0 ;
13503 PyObject *swig_obj[1] ;
13504
13505 if (!args) SWIG_fail;
13506 swig_obj[0] = args;
13507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13508 if (!SWIG_IsOK(res1)) {
13509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13510 }
13511 arg1 = reinterpret_cast< wxImage * >(argp1);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 (arg1)->Destroy();
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 resultobj = SWIG_Py_Void();
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 int arg2 ;
13529 int arg3 ;
13530 SwigValueWrapper<wxImage > result;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 int val2 ;
13534 int ecode2 = 0 ;
13535 int val3 ;
13536 int ecode3 = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "width",(char *) "height", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13548 }
13549 arg1 = reinterpret_cast< wxImage * >(argp1);
13550 ecode2 = SWIG_AsVal_int(obj1, &val2);
13551 if (!SWIG_IsOK(ecode2)) {
13552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13553 }
13554 arg2 = static_cast< int >(val2);
13555 ecode3 = SWIG_AsVal_int(obj2, &val3);
13556 if (!SWIG_IsOK(ecode3)) {
13557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13558 }
13559 arg3 = static_cast< int >(val3);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = (arg1)->Scale(arg2,arg3);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 SwigValueWrapper<wxImage > result;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 PyObject * obj2 = 0 ;
13588 char * kwnames[] = {
13589 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13590 };
13591
13592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13596 }
13597 arg1 = reinterpret_cast< wxImage * >(argp1);
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 ecode3 = SWIG_AsVal_int(obj2, &val3);
13604 if (!SWIG_IsOK(ecode3)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13606 }
13607 arg3 = static_cast< int >(val3);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 int arg2 ;
13625 int arg3 ;
13626 wxImage *result = 0 ;
13627 void *argp1 = 0 ;
13628 int res1 = 0 ;
13629 int val2 ;
13630 int ecode2 = 0 ;
13631 int val3 ;
13632 int ecode3 = 0 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 PyObject * obj2 = 0 ;
13636 char * kwnames[] = {
13637 (char *) "self",(char *) "width",(char *) "height", NULL
13638 };
13639
13640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13642 if (!SWIG_IsOK(res1)) {
13643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13644 }
13645 arg1 = reinterpret_cast< wxImage * >(argp1);
13646 ecode2 = SWIG_AsVal_int(obj1, &val2);
13647 if (!SWIG_IsOK(ecode2)) {
13648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13649 }
13650 arg2 = static_cast< int >(val2);
13651 ecode3 = SWIG_AsVal_int(obj2, &val3);
13652 if (!SWIG_IsOK(ecode3)) {
13653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13654 }
13655 arg3 = static_cast< int >(val3);
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 {
13659 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13660 result = (wxImage *) &_result_ref;
13661 }
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13673 PyObject *resultobj = 0;
13674 wxImage *arg1 = (wxImage *) 0 ;
13675 wxSize *arg2 = 0 ;
13676 wxPoint *arg3 = 0 ;
13677 int arg4 = (int) -1 ;
13678 int arg5 = (int) -1 ;
13679 int arg6 = (int) -1 ;
13680 wxImage *result = 0 ;
13681 void *argp1 = 0 ;
13682 int res1 = 0 ;
13683 wxSize temp2 ;
13684 wxPoint temp3 ;
13685 int val4 ;
13686 int ecode4 = 0 ;
13687 int val5 ;
13688 int ecode5 = 0 ;
13689 int val6 ;
13690 int ecode6 = 0 ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 PyObject * obj2 = 0 ;
13694 PyObject * obj3 = 0 ;
13695 PyObject * obj4 = 0 ;
13696 PyObject * obj5 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 {
13708 arg2 = &temp2;
13709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13710 }
13711 {
13712 arg3 = &temp3;
13713 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13714 }
13715 if (obj3) {
13716 ecode4 = SWIG_AsVal_int(obj3, &val4);
13717 if (!SWIG_IsOK(ecode4)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13719 }
13720 arg4 = static_cast< int >(val4);
13721 }
13722 if (obj4) {
13723 ecode5 = SWIG_AsVal_int(obj4, &val5);
13724 if (!SWIG_IsOK(ecode5)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13726 }
13727 arg5 = static_cast< int >(val5);
13728 }
13729 if (obj5) {
13730 ecode6 = SWIG_AsVal_int(obj5, &val6);
13731 if (!SWIG_IsOK(ecode6)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13733 }
13734 arg6 = static_cast< int >(val6);
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 {
13739 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13740 result = (wxImage *) &_result_ref;
13741 }
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13746 return resultobj;
13747 fail:
13748 return NULL;
13749 }
13750
13751
13752 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13753 PyObject *resultobj = 0;
13754 wxImage *arg1 = (wxImage *) 0 ;
13755 int arg2 ;
13756 int arg3 ;
13757 byte arg4 ;
13758 byte arg5 ;
13759 byte arg6 ;
13760 void *argp1 = 0 ;
13761 int res1 = 0 ;
13762 int val2 ;
13763 int ecode2 = 0 ;
13764 int val3 ;
13765 int ecode3 = 0 ;
13766 unsigned char val4 ;
13767 int ecode4 = 0 ;
13768 unsigned char val5 ;
13769 int ecode5 = 0 ;
13770 unsigned char val6 ;
13771 int ecode6 = 0 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 PyObject * obj3 = 0 ;
13776 PyObject * obj4 = 0 ;
13777 PyObject * obj5 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13786 }
13787 arg1 = reinterpret_cast< wxImage * >(argp1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 if (!SWIG_IsOK(ecode3)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13796 }
13797 arg3 = static_cast< int >(val3);
13798 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13799 if (!SWIG_IsOK(ecode4)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13801 }
13802 arg4 = static_cast< byte >(val4);
13803 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13804 if (!SWIG_IsOK(ecode5)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13806 }
13807 arg5 = static_cast< byte >(val5);
13808 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13809 if (!SWIG_IsOK(ecode6)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13811 }
13812 arg6 = static_cast< byte >(val6);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 wxRect *arg2 = 0 ;
13830 byte arg3 ;
13831 byte arg4 ;
13832 byte arg5 ;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 wxRect temp2 ;
13836 unsigned char val3 ;
13837 int ecode3 = 0 ;
13838 unsigned char val4 ;
13839 int ecode4 = 0 ;
13840 unsigned char val5 ;
13841 int ecode5 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 PyObject * obj3 = 0 ;
13846 PyObject * obj4 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13853 if (!SWIG_IsOK(res1)) {
13854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13855 }
13856 arg1 = reinterpret_cast< wxImage * >(argp1);
13857 {
13858 arg2 = &temp2;
13859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13860 }
13861 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13864 }
13865 arg3 = static_cast< byte >(val3);
13866 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13867 if (!SWIG_IsOK(ecode4)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13869 }
13870 arg4 = static_cast< byte >(val4);
13871 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13872 if (!SWIG_IsOK(ecode5)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13874 }
13875 arg5 = static_cast< byte >(val5);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_Py_Void();
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxImage *arg1 = (wxImage *) 0 ;
13892 int arg2 ;
13893 int arg3 ;
13894 byte result;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 int val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (byte)(arg1)->GetRed(arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj = 0;
13939 wxImage *arg1 = (wxImage *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 byte result;
13943 void *argp1 = 0 ;
13944 int res1 = 0 ;
13945 int val2 ;
13946 int ecode2 = 0 ;
13947 int val3 ;
13948 int ecode3 = 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 PyObject * obj2 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "self",(char *) "x",(char *) "y", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13960 }
13961 arg1 = reinterpret_cast< wxImage * >(argp1);
13962 ecode2 = SWIG_AsVal_int(obj1, &val2);
13963 if (!SWIG_IsOK(ecode2)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13965 }
13966 arg2 = static_cast< int >(val2);
13967 ecode3 = SWIG_AsVal_int(obj2, &val3);
13968 if (!SWIG_IsOK(ecode3)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13970 }
13971 arg3 = static_cast< int >(val3);
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 result = (byte)(arg1)->GetGreen(arg2,arg3);
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = 0;
13987 wxImage *arg1 = (wxImage *) 0 ;
13988 int arg2 ;
13989 int arg3 ;
13990 byte result;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 int val2 ;
13994 int ecode2 = 0 ;
13995 int val3 ;
13996 int ecode3 = 0 ;
13997 PyObject * obj0 = 0 ;
13998 PyObject * obj1 = 0 ;
13999 PyObject * obj2 = 0 ;
14000 char * kwnames[] = {
14001 (char *) "self",(char *) "x",(char *) "y", NULL
14002 };
14003
14004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14008 }
14009 arg1 = reinterpret_cast< wxImage * >(argp1);
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14013 }
14014 arg2 = static_cast< int >(val2);
14015 ecode3 = SWIG_AsVal_int(obj2, &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14018 }
14019 arg3 = static_cast< int >(val3);
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 result = (byte)(arg1)->GetBlue(arg2,arg3);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxImage *arg1 = (wxImage *) 0 ;
14036 int arg2 ;
14037 int arg3 ;
14038 byte arg4 ;
14039 void *argp1 = 0 ;
14040 int res1 = 0 ;
14041 int val2 ;
14042 int ecode2 = 0 ;
14043 int val3 ;
14044 int ecode3 = 0 ;
14045 unsigned char val4 ;
14046 int ecode4 = 0 ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 PyObject * obj2 = 0 ;
14050 PyObject * obj3 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 ecode3 = SWIG_AsVal_int(obj2, &val3);
14067 if (!SWIG_IsOK(ecode3)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14069 }
14070 arg3 = static_cast< int >(val3);
14071 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14072 if (!SWIG_IsOK(ecode4)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14074 }
14075 arg4 = static_cast< byte >(val4);
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 (arg1)->SetAlpha(arg2,arg3,arg4);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxImage *arg1 = (wxImage *) 0 ;
14092 int arg2 ;
14093 int arg3 ;
14094 byte result;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 int val2 ;
14098 int ecode2 = 0 ;
14099 int val3 ;
14100 int ecode3 = 0 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "x",(char *) "y", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14112 }
14113 arg1 = reinterpret_cast< wxImage * >(argp1);
14114 ecode2 = SWIG_AsVal_int(obj1, &val2);
14115 if (!SWIG_IsOK(ecode2)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14117 }
14118 arg2 = static_cast< int >(val2);
14119 ecode3 = SWIG_AsVal_int(obj2, &val3);
14120 if (!SWIG_IsOK(ecode3)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14122 }
14123 arg3 = static_cast< int >(val3);
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14127 wxPyEndAllowThreads(__tstate);
14128 if (PyErr_Occurred()) SWIG_fail;
14129 }
14130 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14131 return resultobj;
14132 fail:
14133 return NULL;
14134 }
14135
14136
14137 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14138 PyObject *resultobj = 0;
14139 wxImage *arg1 = (wxImage *) 0 ;
14140 bool result;
14141 void *argp1 = 0 ;
14142 int res1 = 0 ;
14143 PyObject *swig_obj[1] ;
14144
14145 if (!args) SWIG_fail;
14146 swig_obj[0] = args;
14147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14148 if (!SWIG_IsOK(res1)) {
14149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14150 }
14151 arg1 = reinterpret_cast< wxImage * >(argp1);
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (bool)(arg1)->HasAlpha();
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 {
14159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14160 }
14161 return resultobj;
14162 fail:
14163 return NULL;
14164 }
14165
14166
14167 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 PyObject *resultobj = 0;
14169 wxImage *arg1 = (wxImage *) 0 ;
14170 void *argp1 = 0 ;
14171 int res1 = 0 ;
14172 PyObject *swig_obj[1] ;
14173
14174 if (!args) SWIG_fail;
14175 swig_obj[0] = args;
14176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 (arg1)->InitAlpha();
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 resultobj = SWIG_Py_Void();
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj = 0;
14196 wxImage *arg1 = (wxImage *) 0 ;
14197 int arg2 ;
14198 int arg3 ;
14199 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14200 bool result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 int val2 ;
14204 int ecode2 = 0 ;
14205 int val3 ;
14206 int ecode3 = 0 ;
14207 unsigned char val4 ;
14208 int ecode4 = 0 ;
14209 PyObject * obj0 = 0 ;
14210 PyObject * obj1 = 0 ;
14211 PyObject * obj2 = 0 ;
14212 PyObject * obj3 = 0 ;
14213 char * kwnames[] = {
14214 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14215 };
14216
14217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14221 }
14222 arg1 = reinterpret_cast< wxImage * >(argp1);
14223 ecode2 = SWIG_AsVal_int(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14226 }
14227 arg2 = static_cast< int >(val2);
14228 ecode3 = SWIG_AsVal_int(obj2, &val3);
14229 if (!SWIG_IsOK(ecode3)) {
14230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14231 }
14232 arg3 = static_cast< int >(val3);
14233 if (obj3) {
14234 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14235 if (!SWIG_IsOK(ecode4)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14237 }
14238 arg4 = static_cast< byte >(val4);
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 {
14247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14248 }
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 wxImage *arg1 = (wxImage *) 0 ;
14258 byte *arg2 = (byte *) 0 ;
14259 byte *arg3 = (byte *) 0 ;
14260 byte *arg4 = (byte *) 0 ;
14261 byte arg5 = (byte) 0 ;
14262 byte arg6 = (byte) 0 ;
14263 byte arg7 = (byte) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 byte temp2 ;
14268 int res2 = SWIG_TMPOBJ ;
14269 byte temp3 ;
14270 int res3 = SWIG_TMPOBJ ;
14271 byte temp4 ;
14272 int res4 = SWIG_TMPOBJ ;
14273 unsigned char val5 ;
14274 int ecode5 = 0 ;
14275 unsigned char val6 ;
14276 int ecode6 = 0 ;
14277 unsigned char val7 ;
14278 int ecode7 = 0 ;
14279 PyObject * obj0 = 0 ;
14280 PyObject * obj1 = 0 ;
14281 PyObject * obj2 = 0 ;
14282 PyObject * obj3 = 0 ;
14283 char * kwnames[] = {
14284 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14285 };
14286
14287 arg2 = &temp2;
14288 arg3 = &temp3;
14289 arg4 = &temp4;
14290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14292 if (!SWIG_IsOK(res1)) {
14293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14294 }
14295 arg1 = reinterpret_cast< wxImage * >(argp1);
14296 if (obj1) {
14297 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14298 if (!SWIG_IsOK(ecode5)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14300 }
14301 arg5 = static_cast< byte >(val5);
14302 }
14303 if (obj2) {
14304 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14305 if (!SWIG_IsOK(ecode6)) {
14306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14307 }
14308 arg6 = static_cast< byte >(val6);
14309 }
14310 if (obj3) {
14311 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14312 if (!SWIG_IsOK(ecode7)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14314 }
14315 arg7 = static_cast< byte >(val7);
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14325 }
14326 if (SWIG_IsTmpObj(res2)) {
14327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14328 } else {
14329 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14331 }
14332 if (SWIG_IsTmpObj(res3)) {
14333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14334 } else {
14335 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14337 }
14338 if (SWIG_IsTmpObj(res4)) {
14339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14340 } else {
14341 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14343 }
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj = 0;
14352 wxImage *arg1 = (wxImage *) 0 ;
14353 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14354 bool result;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 unsigned char val2 ;
14358 int ecode2 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 char * kwnames[] = {
14362 (char *) "self",(char *) "threshold", NULL
14363 };
14364
14365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14369 }
14370 arg1 = reinterpret_cast< wxImage * >(argp1);
14371 if (obj1) {
14372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14373 if (!SWIG_IsOK(ecode2)) {
14374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14375 }
14376 arg2 = static_cast< byte >(val2);
14377 }
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj = 0;
14395 wxImage *arg1 = (wxImage *) 0 ;
14396 byte arg2 ;
14397 byte arg3 ;
14398 byte arg4 ;
14399 bool result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 unsigned char val2 ;
14403 int ecode2 = 0 ;
14404 unsigned char val3 ;
14405 int ecode3 = 0 ;
14406 unsigned char val4 ;
14407 int ecode4 = 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 PyObject * obj2 = 0 ;
14411 PyObject * obj3 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14423 if (!SWIG_IsOK(ecode2)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14425 }
14426 arg2 = static_cast< byte >(val2);
14427 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14428 if (!SWIG_IsOK(ecode3)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14430 }
14431 arg3 = static_cast< byte >(val3);
14432 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14433 if (!SWIG_IsOK(ecode4)) {
14434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14435 }
14436 arg4 = static_cast< byte >(val4);
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 {
14444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14445 }
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14453 PyObject *resultobj = 0;
14454 wxImage *arg1 = (wxImage *) 0 ;
14455 wxImage *arg2 = 0 ;
14456 byte arg3 ;
14457 byte arg4 ;
14458 byte arg5 ;
14459 bool result;
14460 void *argp1 = 0 ;
14461 int res1 = 0 ;
14462 void *argp2 = 0 ;
14463 int res2 = 0 ;
14464 unsigned char val3 ;
14465 int ecode3 = 0 ;
14466 unsigned char val4 ;
14467 int ecode4 = 0 ;
14468 unsigned char val5 ;
14469 int ecode5 = 0 ;
14470 PyObject * obj0 = 0 ;
14471 PyObject * obj1 = 0 ;
14472 PyObject * obj2 = 0 ;
14473 PyObject * obj3 = 0 ;
14474 PyObject * obj4 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14483 }
14484 arg1 = reinterpret_cast< wxImage * >(argp1);
14485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14486 if (!SWIG_IsOK(res2)) {
14487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14488 }
14489 if (!argp2) {
14490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14491 }
14492 arg2 = reinterpret_cast< wxImage * >(argp2);
14493 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14494 if (!SWIG_IsOK(ecode3)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14496 }
14497 arg3 = static_cast< byte >(val3);
14498 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14499 if (!SWIG_IsOK(ecode4)) {
14500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14501 }
14502 arg4 = static_cast< byte >(val4);
14503 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14504 if (!SWIG_IsOK(ecode5)) {
14505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14506 }
14507 arg5 = static_cast< byte >(val5);
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 {
14515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14516 }
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj = 0;
14525 wxString *arg1 = 0 ;
14526 bool result;
14527 bool temp1 = false ;
14528 PyObject * obj0 = 0 ;
14529 char * kwnames[] = {
14530 (char *) "filename", NULL
14531 };
14532
14533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14534 {
14535 arg1 = wxString_in_helper(obj0);
14536 if (arg1 == NULL) SWIG_fail;
14537 temp1 = true;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 {
14546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14547 }
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp1)
14556 delete arg1;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxString *arg1 = 0 ;
14565 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14566 int result;
14567 bool temp1 = false ;
14568 long val2 ;
14569 int ecode2 = 0 ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "filename",(char *) "type", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14577 {
14578 arg1 = wxString_in_helper(obj0);
14579 if (arg1 == NULL) SWIG_fail;
14580 temp1 = true;
14581 }
14582 if (obj1) {
14583 ecode2 = SWIG_AsVal_long(obj1, &val2);
14584 if (!SWIG_IsOK(ecode2)) {
14585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14586 }
14587 arg2 = static_cast< long >(val2);
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_From_int(static_cast< int >(result));
14596 {
14597 if (temp1)
14598 delete arg1;
14599 }
14600 return resultobj;
14601 fail:
14602 {
14603 if (temp1)
14604 delete arg1;
14605 }
14606 return NULL;
14607 }
14608
14609
14610 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj = 0;
14612 wxImage *arg1 = (wxImage *) 0 ;
14613 wxString *arg2 = 0 ;
14614 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14615 int arg4 = (int) -1 ;
14616 bool result;
14617 void *argp1 = 0 ;
14618 int res1 = 0 ;
14619 bool temp2 = false ;
14620 long val3 ;
14621 int ecode3 = 0 ;
14622 int val4 ;
14623 int ecode4 = 0 ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 PyObject * obj2 = 0 ;
14627 PyObject * obj3 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImage * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 if (obj2) {
14644 ecode3 = SWIG_AsVal_long(obj2, &val3);
14645 if (!SWIG_IsOK(ecode3)) {
14646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14647 }
14648 arg3 = static_cast< long >(val3);
14649 }
14650 if (obj3) {
14651 ecode4 = SWIG_AsVal_int(obj3, &val4);
14652 if (!SWIG_IsOK(ecode4)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14654 }
14655 arg4 = static_cast< int >(val4);
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 {
14667 if (temp2)
14668 delete arg2;
14669 }
14670 return resultobj;
14671 fail:
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 return NULL;
14677 }
14678
14679
14680 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14681 PyObject *resultobj = 0;
14682 wxImage *arg1 = (wxImage *) 0 ;
14683 wxString *arg2 = 0 ;
14684 wxString *arg3 = 0 ;
14685 int arg4 = (int) -1 ;
14686 bool result;
14687 void *argp1 = 0 ;
14688 int res1 = 0 ;
14689 bool temp2 = false ;
14690 bool temp3 = false ;
14691 int val4 ;
14692 int ecode4 = 0 ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 PyObject * obj3 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14705 }
14706 arg1 = reinterpret_cast< wxImage * >(argp1);
14707 {
14708 arg2 = wxString_in_helper(obj1);
14709 if (arg2 == NULL) SWIG_fail;
14710 temp2 = true;
14711 }
14712 {
14713 arg3 = wxString_in_helper(obj2);
14714 if (arg3 == NULL) SWIG_fail;
14715 temp3 = true;
14716 }
14717 if (obj3) {
14718 ecode4 = SWIG_AsVal_int(obj3, &val4);
14719 if (!SWIG_IsOK(ecode4)) {
14720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14721 }
14722 arg4 = static_cast< int >(val4);
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 {
14731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14732 }
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 {
14738 if (temp3)
14739 delete arg3;
14740 }
14741 return resultobj;
14742 fail:
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return NULL;
14752 }
14753
14754
14755 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14756 PyObject *resultobj = 0;
14757 wxImage *arg1 = (wxImage *) 0 ;
14758 wxString *arg2 = 0 ;
14759 int arg3 ;
14760 bool result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 bool temp2 = false ;
14764 int val3 ;
14765 int ecode3 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 PyObject * obj2 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "name",(char *) "type", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14777 }
14778 arg1 = reinterpret_cast< wxImage * >(argp1);
14779 {
14780 arg2 = wxString_in_helper(obj1);
14781 if (arg2 == NULL) SWIG_fail;
14782 temp2 = true;
14783 }
14784 ecode3 = SWIG_AsVal_int(obj2, &val3);
14785 if (!SWIG_IsOK(ecode3)) {
14786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14787 }
14788 arg3 = static_cast< int >(val3);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (temp2)
14800 delete arg2;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj = 0;
14814 wxImage *arg1 = (wxImage *) 0 ;
14815 wxString *arg2 = 0 ;
14816 wxString *arg3 = 0 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 bool temp2 = false ;
14821 bool temp3 = false ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 char * kwnames[] = {
14826 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14827 };
14828
14829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14833 }
14834 arg1 = reinterpret_cast< wxImage * >(argp1);
14835 {
14836 arg2 = wxString_in_helper(obj1);
14837 if (arg2 == NULL) SWIG_fail;
14838 temp2 = true;
14839 }
14840 {
14841 arg3 = wxString_in_helper(obj2);
14842 if (arg3 == NULL) SWIG_fail;
14843 temp3 = true;
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 {
14855 if (temp2)
14856 delete arg2;
14857 }
14858 {
14859 if (temp3)
14860 delete arg3;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (temp2)
14866 delete arg2;
14867 }
14868 {
14869 if (temp3)
14870 delete arg3;
14871 }
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxInputStream *arg1 = 0 ;
14879 bool result;
14880 wxPyInputStream *temp1 ;
14881 bool created1 ;
14882 PyObject * obj0 = 0 ;
14883 char * kwnames[] = {
14884 (char *) "stream", NULL
14885 };
14886
14887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14888 {
14889 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14890 arg1 = temp1->m_wxis;
14891 created1 = false;
14892 } else {
14893 PyErr_Clear(); // clear the failure of the wxPyConvert above
14894 arg1 = wxPyCBInputStream_create(obj0, false);
14895 if (arg1 == NULL) {
14896 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14897 SWIG_fail;
14898 }
14899 created1 = true;
14900 }
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxImage::CanRead(*arg1);
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 {
14909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14910 }
14911 {
14912 if (created1) delete arg1;
14913 }
14914 return resultobj;
14915 fail:
14916 {
14917 if (created1) delete arg1;
14918 }
14919 return NULL;
14920 }
14921
14922
14923 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj = 0;
14925 wxImage *arg1 = (wxImage *) 0 ;
14926 wxInputStream *arg2 = 0 ;
14927 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14928 int arg4 = (int) -1 ;
14929 bool result;
14930 void *argp1 = 0 ;
14931 int res1 = 0 ;
14932 wxPyInputStream *temp2 ;
14933 bool created2 ;
14934 long val3 ;
14935 int ecode3 = 0 ;
14936 int val4 ;
14937 int ecode4 = 0 ;
14938 PyObject * obj0 = 0 ;
14939 PyObject * obj1 = 0 ;
14940 PyObject * obj2 = 0 ;
14941 PyObject * obj3 = 0 ;
14942 char * kwnames[] = {
14943 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14944 };
14945
14946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 {
14953 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14954 arg2 = temp2->m_wxis;
14955 created2 = false;
14956 } else {
14957 PyErr_Clear(); // clear the failure of the wxPyConvert above
14958 arg2 = wxPyCBInputStream_create(obj1, false);
14959 if (arg2 == NULL) {
14960 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14961 SWIG_fail;
14962 }
14963 created2 = true;
14964 }
14965 }
14966 if (obj2) {
14967 ecode3 = SWIG_AsVal_long(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14970 }
14971 arg3 = static_cast< long >(val3);
14972 }
14973 if (obj3) {
14974 ecode4 = SWIG_AsVal_int(obj3, &val4);
14975 if (!SWIG_IsOK(ecode4)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14977 }
14978 arg4 = static_cast< int >(val4);
14979 }
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 {
14987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14988 }
14989 {
14990 if (created2) delete arg2;
14991 }
14992 return resultobj;
14993 fail:
14994 {
14995 if (created2) delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 wxInputStream *arg2 = 0 ;
15005 wxString *arg3 = 0 ;
15006 int arg4 = (int) -1 ;
15007 bool result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 wxPyInputStream *temp2 ;
15011 bool created2 ;
15012 bool temp3 = false ;
15013 int val4 ;
15014 int ecode4 = 0 ;
15015 PyObject * obj0 = 0 ;
15016 PyObject * obj1 = 0 ;
15017 PyObject * obj2 = 0 ;
15018 PyObject * obj3 = 0 ;
15019 char * kwnames[] = {
15020 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15021 };
15022
15023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15027 }
15028 arg1 = reinterpret_cast< wxImage * >(argp1);
15029 {
15030 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15031 arg2 = temp2->m_wxis;
15032 created2 = false;
15033 } else {
15034 PyErr_Clear(); // clear the failure of the wxPyConvert above
15035 arg2 = wxPyCBInputStream_create(obj1, false);
15036 if (arg2 == NULL) {
15037 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15038 SWIG_fail;
15039 }
15040 created2 = true;
15041 }
15042 }
15043 {
15044 arg3 = wxString_in_helper(obj2);
15045 if (arg3 == NULL) SWIG_fail;
15046 temp3 = true;
15047 }
15048 if (obj3) {
15049 ecode4 = SWIG_AsVal_int(obj3, &val4);
15050 if (!SWIG_IsOK(ecode4)) {
15051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15052 }
15053 arg4 = static_cast< int >(val4);
15054 }
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 {
15062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15063 }
15064 {
15065 if (created2) delete arg2;
15066 }
15067 {
15068 if (temp3)
15069 delete arg3;
15070 }
15071 return resultobj;
15072 fail:
15073 {
15074 if (created2) delete arg2;
15075 }
15076 {
15077 if (temp3)
15078 delete arg3;
15079 }
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15085 PyObject *resultobj = 0;
15086 wxImage *arg1 = (wxImage *) 0 ;
15087 bool result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 PyObject *swig_obj[1] ;
15091
15092 if (!args) SWIG_fail;
15093 swig_obj[0] = args;
15094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15095 if (!SWIG_IsOK(res1)) {
15096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15097 }
15098 arg1 = reinterpret_cast< wxImage * >(argp1);
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (bool)(arg1)->Ok();
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 {
15106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15107 }
15108 return resultobj;
15109 fail:
15110 return NULL;
15111 }
15112
15113
15114 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15115 PyObject *resultobj = 0;
15116 wxImage *arg1 = (wxImage *) 0 ;
15117 int result;
15118 void *argp1 = 0 ;
15119 int res1 = 0 ;
15120 PyObject *swig_obj[1] ;
15121
15122 if (!args) SWIG_fail;
15123 swig_obj[0] = args;
15124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15125 if (!SWIG_IsOK(res1)) {
15126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15127 }
15128 arg1 = reinterpret_cast< wxImage * >(argp1);
15129 {
15130 PyThreadState* __tstate = wxPyBeginAllowThreads();
15131 result = (int)(arg1)->GetWidth();
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_From_int(static_cast< int >(result));
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 PyObject *resultobj = 0;
15144 wxImage *arg1 = (wxImage *) 0 ;
15145 int result;
15146 void *argp1 = 0 ;
15147 int res1 = 0 ;
15148 PyObject *swig_obj[1] ;
15149
15150 if (!args) SWIG_fail;
15151 swig_obj[0] = args;
15152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage * >(argp1);
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 result = (int)(arg1)->GetHeight();
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 resultobj = SWIG_From_int(static_cast< int >(result));
15164 return resultobj;
15165 fail:
15166 return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171 PyObject *resultobj = 0;
15172 wxImage *arg1 = (wxImage *) 0 ;
15173 wxSize result;
15174 void *argp1 = 0 ;
15175 int res1 = 0 ;
15176 PyObject *swig_obj[1] ;
15177
15178 if (!args) SWIG_fail;
15179 swig_obj[0] = args;
15180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15181 if (!SWIG_IsOK(res1)) {
15182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15183 }
15184 arg1 = reinterpret_cast< wxImage * >(argp1);
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 result = wxImage_GetSize(arg1);
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = 0;
15200 wxImage *arg1 = (wxImage *) 0 ;
15201 wxRect *arg2 = 0 ;
15202 SwigValueWrapper<wxImage > result;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 wxRect temp2 ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 char * kwnames[] = {
15209 (char *) "self",(char *) "rect", NULL
15210 };
15211
15212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 arg2 = &temp2;
15220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15221 }
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj = 0;
15237 wxImage *arg1 = (wxImage *) 0 ;
15238 wxSize *arg2 = 0 ;
15239 wxPoint *arg3 = 0 ;
15240 int arg4 = (int) -1 ;
15241 int arg5 = (int) -1 ;
15242 int arg6 = (int) -1 ;
15243 SwigValueWrapper<wxImage > result;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 wxSize temp2 ;
15247 wxPoint temp3 ;
15248 int val4 ;
15249 int ecode4 = 0 ;
15250 int val5 ;
15251 int ecode5 = 0 ;
15252 int val6 ;
15253 int ecode6 = 0 ;
15254 PyObject * obj0 = 0 ;
15255 PyObject * obj1 = 0 ;
15256 PyObject * obj2 = 0 ;
15257 PyObject * obj3 = 0 ;
15258 PyObject * obj4 = 0 ;
15259 PyObject * obj5 = 0 ;
15260 char * kwnames[] = {
15261 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15262 };
15263
15264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15268 }
15269 arg1 = reinterpret_cast< wxImage * >(argp1);
15270 {
15271 arg2 = &temp2;
15272 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15273 }
15274 {
15275 arg3 = &temp3;
15276 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15277 }
15278 if (obj3) {
15279 ecode4 = SWIG_AsVal_int(obj3, &val4);
15280 if (!SWIG_IsOK(ecode4)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15282 }
15283 arg4 = static_cast< int >(val4);
15284 }
15285 if (obj4) {
15286 ecode5 = SWIG_AsVal_int(obj4, &val5);
15287 if (!SWIG_IsOK(ecode5)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15289 }
15290 arg5 = static_cast< int >(val5);
15291 }
15292 if (obj5) {
15293 ecode6 = SWIG_AsVal_int(obj5, &val6);
15294 if (!SWIG_IsOK(ecode6)) {
15295 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15296 }
15297 arg6 = static_cast< int >(val6);
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15313 PyObject *resultobj = 0;
15314 wxImage *arg1 = (wxImage *) 0 ;
15315 SwigValueWrapper<wxImage > result;
15316 void *argp1 = 0 ;
15317 int res1 = 0 ;
15318 PyObject *swig_obj[1] ;
15319
15320 if (!args) SWIG_fail;
15321 swig_obj[0] = args;
15322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage * >(argp1);
15327 {
15328 PyThreadState* __tstate = wxPyBeginAllowThreads();
15329 result = (arg1)->Copy();
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj = 0;
15342 wxImage *arg1 = (wxImage *) 0 ;
15343 wxImage *arg2 = 0 ;
15344 int arg3 ;
15345 int arg4 ;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 void *argp2 = 0 ;
15349 int res2 = 0 ;
15350 int val3 ;
15351 int ecode3 = 0 ;
15352 int val4 ;
15353 int ecode4 = 0 ;
15354 PyObject * obj0 = 0 ;
15355 PyObject * obj1 = 0 ;
15356 PyObject * obj2 = 0 ;
15357 PyObject * obj3 = 0 ;
15358 char * kwnames[] = {
15359 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15360 };
15361
15362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15364 if (!SWIG_IsOK(res1)) {
15365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15366 }
15367 arg1 = reinterpret_cast< wxImage * >(argp1);
15368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15369 if (!SWIG_IsOK(res2)) {
15370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15371 }
15372 if (!argp2) {
15373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15374 }
15375 arg2 = reinterpret_cast< wxImage * >(argp2);
15376 ecode3 = SWIG_AsVal_int(obj2, &val3);
15377 if (!SWIG_IsOK(ecode3)) {
15378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15379 }
15380 arg3 = static_cast< int >(val3);
15381 ecode4 = SWIG_AsVal_int(obj3, &val4);
15382 if (!SWIG_IsOK(ecode4)) {
15383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15384 }
15385 arg4 = static_cast< int >(val4);
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage *arg1 = (wxImage *) 0 ;
15402 PyObject *result = 0 ;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (PyObject *)wxImage_GetData(arg1);
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj = 0;
15429 wxImage *arg1 = (wxImage *) 0 ;
15430 buffer arg2 ;
15431 int arg3 ;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "data", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) 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_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 wxImage_SetData(arg1,arg2,arg3);
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_Py_Void();
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 PyObject *resultobj = 0;
15464 wxImage *arg1 = (wxImage *) 0 ;
15465 PyObject *result = 0 ;
15466 void *argp1 = 0 ;
15467 int res1 = 0 ;
15468 PyObject *swig_obj[1] ;
15469
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = result;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj = 0;
15492 wxImage *arg1 = (wxImage *) 0 ;
15493 buffer arg2 ;
15494 int arg3 ;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "self",(char *) "data", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage * >(argp1);
15509 {
15510 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 wxImage_SetDataBuffer(arg1,arg2,arg3);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 PyObject *result = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15538 }
15539 arg1 = reinterpret_cast< wxImage * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (PyObject *)wxImage_GetAlphaData(arg1);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = result;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxImage *arg1 = (wxImage *) 0 ;
15556 buffer arg2 ;
15557 int arg3 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "alpha", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetAlphaData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 char * kwnames[] = {
15626 (char *) "self",(char *) "alpha", NULL
15627 };
15628
15629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15633 }
15634 arg1 = reinterpret_cast< wxImage * >(argp1);
15635 {
15636 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15637 }
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 byte arg2 ;
15655 byte arg3 ;
15656 byte arg4 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 unsigned char val2 ;
15660 int ecode2 = 0 ;
15661 unsigned char val3 ;
15662 int ecode3 = 0 ;
15663 unsigned char val4 ;
15664 int ecode4 = 0 ;
15665 PyObject * obj0 = 0 ;
15666 PyObject * obj1 = 0 ;
15667 PyObject * obj2 = 0 ;
15668 PyObject * obj3 = 0 ;
15669 char * kwnames[] = {
15670 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15671 };
15672
15673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15677 }
15678 arg1 = reinterpret_cast< wxImage * >(argp1);
15679 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15680 if (!SWIG_IsOK(ecode2)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15682 }
15683 arg2 = static_cast< byte >(val2);
15684 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15685 if (!SWIG_IsOK(ecode3)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15687 }
15688 arg3 = static_cast< byte >(val3);
15689 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15690 if (!SWIG_IsOK(ecode4)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15692 }
15693 arg4 = static_cast< byte >(val4);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->SetMaskColour(arg2,arg3,arg4);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 byte *arg2 = (byte *) 0 ;
15711 byte *arg3 = (byte *) 0 ;
15712 byte *arg4 = (byte *) 0 ;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 byte temp2 ;
15716 int res2 = SWIG_TMPOBJ ;
15717 byte temp3 ;
15718 int res3 = SWIG_TMPOBJ ;
15719 byte temp4 ;
15720 int res4 = SWIG_TMPOBJ ;
15721 PyObject *swig_obj[1] ;
15722
15723 arg2 = &temp2;
15724 arg3 = &temp3;
15725 arg4 = &temp4;
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15731 }
15732 arg1 = reinterpret_cast< wxImage * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_Py_Void();
15740 if (SWIG_IsTmpObj(res2)) {
15741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15742 } else {
15743 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15745 }
15746 if (SWIG_IsTmpObj(res3)) {
15747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15748 } else {
15749 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15751 }
15752 if (SWIG_IsTmpObj(res4)) {
15753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15754 } else {
15755 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 byte result;
15768 void *argp1 = 0 ;
15769 int res1 = 0 ;
15770 PyObject *swig_obj[1] ;
15771
15772 if (!args) SWIG_fail;
15773 swig_obj[0] = args;
15774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15775 if (!SWIG_IsOK(res1)) {
15776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15777 }
15778 arg1 = reinterpret_cast< wxImage * >(argp1);
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (byte)(arg1)->GetMaskRed();
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15793 PyObject *resultobj = 0;
15794 wxImage *arg1 = (wxImage *) 0 ;
15795 byte result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 PyObject *swig_obj[1] ;
15799
15800 if (!args) SWIG_fail;
15801 swig_obj[0] = args;
15802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15803 if (!SWIG_IsOK(res1)) {
15804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15805 }
15806 arg1 = reinterpret_cast< wxImage * >(argp1);
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (byte)(arg1)->GetMaskGreen();
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15821 PyObject *resultobj = 0;
15822 wxImage *arg1 = (wxImage *) 0 ;
15823 byte result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 PyObject *swig_obj[1] ;
15827
15828 if (!args) SWIG_fail;
15829 swig_obj[0] = args;
15830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (byte)(arg1)->GetMaskBlue();
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 wxImage *arg1 = (wxImage *) 0 ;
15851 bool arg2 = (bool) true ;
15852 void *argp1 = 0 ;
15853 int res1 = 0 ;
15854 bool val2 ;
15855 int ecode2 = 0 ;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 char * kwnames[] = {
15859 (char *) "self",(char *) "mask", NULL
15860 };
15861
15862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15864 if (!SWIG_IsOK(res1)) {
15865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15866 }
15867 arg1 = reinterpret_cast< wxImage * >(argp1);
15868 if (obj1) {
15869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15870 if (!SWIG_IsOK(ecode2)) {
15871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15872 }
15873 arg2 = static_cast< bool >(val2);
15874 }
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 (arg1)->SetMask(arg2);
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 resultobj = SWIG_Py_Void();
15882 return resultobj;
15883 fail:
15884 return NULL;
15885 }
15886
15887
15888 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15889 PyObject *resultobj = 0;
15890 wxImage *arg1 = (wxImage *) 0 ;
15891 bool result;
15892 void *argp1 = 0 ;
15893 int res1 = 0 ;
15894 PyObject *swig_obj[1] ;
15895
15896 if (!args) SWIG_fail;
15897 swig_obj[0] = args;
15898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (bool)(arg1)->HasMask();
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 {
15910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15911 }
15912 return resultobj;
15913 fail:
15914 return NULL;
15915 }
15916
15917
15918 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15919 PyObject *resultobj = 0;
15920 wxImage *arg1 = (wxImage *) 0 ;
15921 double arg2 ;
15922 wxPoint *arg3 = 0 ;
15923 bool arg4 = (bool) true ;
15924 wxPoint *arg5 = (wxPoint *) NULL ;
15925 SwigValueWrapper<wxImage > result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 double val2 ;
15929 int ecode2 = 0 ;
15930 wxPoint temp3 ;
15931 bool val4 ;
15932 int ecode4 = 0 ;
15933 void *argp5 = 0 ;
15934 int res5 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 PyObject * obj2 = 0 ;
15938 PyObject * obj3 = 0 ;
15939 PyObject * obj4 = 0 ;
15940 char * kwnames[] = {
15941 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15942 };
15943
15944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15946 if (!SWIG_IsOK(res1)) {
15947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15948 }
15949 arg1 = reinterpret_cast< wxImage * >(argp1);
15950 ecode2 = SWIG_AsVal_double(obj1, &val2);
15951 if (!SWIG_IsOK(ecode2)) {
15952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15953 }
15954 arg2 = static_cast< double >(val2);
15955 {
15956 arg3 = &temp3;
15957 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15958 }
15959 if (obj3) {
15960 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15961 if (!SWIG_IsOK(ecode4)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15963 }
15964 arg4 = static_cast< bool >(val4);
15965 }
15966 if (obj4) {
15967 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15968 if (!SWIG_IsOK(res5)) {
15969 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15970 }
15971 arg5 = reinterpret_cast< wxPoint * >(argp5);
15972 }
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj = 0;
15988 wxImage *arg1 = (wxImage *) 0 ;
15989 bool arg2 = (bool) true ;
15990 SwigValueWrapper<wxImage > result;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 bool val2 ;
15994 int ecode2 = 0 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char * kwnames[] = {
15998 (char *) "self",(char *) "clockwise", NULL
15999 };
16000
16001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16005 }
16006 arg1 = reinterpret_cast< wxImage * >(argp1);
16007 if (obj1) {
16008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16009 if (!SWIG_IsOK(ecode2)) {
16010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16011 }
16012 arg2 = static_cast< bool >(val2);
16013 }
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (arg1)->Rotate90(arg2);
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj = 0;
16029 wxImage *arg1 = (wxImage *) 0 ;
16030 bool arg2 = (bool) true ;
16031 SwigValueWrapper<wxImage > result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 bool val2 ;
16035 int ecode2 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "self",(char *) "horizontally", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16046 }
16047 arg1 = reinterpret_cast< wxImage * >(argp1);
16048 if (obj1) {
16049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16050 if (!SWIG_IsOK(ecode2)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16052 }
16053 arg2 = static_cast< bool >(val2);
16054 }
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 result = (arg1)->Mirror(arg2);
16058 wxPyEndAllowThreads(__tstate);
16059 if (PyErr_Occurred()) SWIG_fail;
16060 }
16061 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16069 PyObject *resultobj = 0;
16070 wxImage *arg1 = (wxImage *) 0 ;
16071 byte arg2 ;
16072 byte arg3 ;
16073 byte arg4 ;
16074 byte arg5 ;
16075 byte arg6 ;
16076 byte arg7 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 unsigned char val2 ;
16080 int ecode2 = 0 ;
16081 unsigned char val3 ;
16082 int ecode3 = 0 ;
16083 unsigned char val4 ;
16084 int ecode4 = 0 ;
16085 unsigned char val5 ;
16086 int ecode5 = 0 ;
16087 unsigned char val6 ;
16088 int ecode6 = 0 ;
16089 unsigned char val7 ;
16090 int ecode7 = 0 ;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 PyObject * obj2 = 0 ;
16094 PyObject * obj3 = 0 ;
16095 PyObject * obj4 = 0 ;
16096 PyObject * obj5 = 0 ;
16097 PyObject * obj6 = 0 ;
16098 char * kwnames[] = {
16099 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16100 };
16101
16102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16106 }
16107 arg1 = reinterpret_cast< wxImage * >(argp1);
16108 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16109 if (!SWIG_IsOK(ecode2)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16111 }
16112 arg2 = static_cast< byte >(val2);
16113 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16114 if (!SWIG_IsOK(ecode3)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16116 }
16117 arg3 = static_cast< byte >(val3);
16118 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16119 if (!SWIG_IsOK(ecode4)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16121 }
16122 arg4 = static_cast< byte >(val4);
16123 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16124 if (!SWIG_IsOK(ecode5)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16126 }
16127 arg5 = static_cast< byte >(val5);
16128 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16129 if (!SWIG_IsOK(ecode6)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16131 }
16132 arg6 = static_cast< byte >(val6);
16133 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16134 if (!SWIG_IsOK(ecode7)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16136 }
16137 arg7 = static_cast< byte >(val7);
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_Py_Void();
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 double arg2 = (double) 0.299 ;
16155 double arg3 = (double) 0.587 ;
16156 double arg4 = (double) 0.114 ;
16157 SwigValueWrapper<wxImage > result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 double val2 ;
16161 int ecode2 = 0 ;
16162 double val3 ;
16163 int ecode3 = 0 ;
16164 double val4 ;
16165 int ecode4 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 PyObject * obj3 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 if (obj1) {
16181 ecode2 = SWIG_AsVal_double(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16184 }
16185 arg2 = static_cast< double >(val2);
16186 }
16187 if (obj2) {
16188 ecode3 = SWIG_AsVal_double(obj2, &val3);
16189 if (!SWIG_IsOK(ecode3)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16191 }
16192 arg3 = static_cast< double >(val3);
16193 }
16194 if (obj3) {
16195 ecode4 = SWIG_AsVal_double(obj3, &val4);
16196 if (!SWIG_IsOK(ecode4)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16198 }
16199 arg4 = static_cast< double >(val4);
16200 }
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj = 0;
16216 wxImage *arg1 = (wxImage *) 0 ;
16217 byte arg2 ;
16218 byte arg3 ;
16219 byte arg4 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 unsigned char val2 ;
16224 int ecode2 = 0 ;
16225 unsigned char val3 ;
16226 int ecode3 = 0 ;
16227 unsigned char val4 ;
16228 int ecode4 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 PyObject * obj3 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16246 }
16247 arg2 = static_cast< byte >(val2);
16248 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16251 }
16252 arg3 = static_cast< byte >(val3);
16253 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16254 if (!SWIG_IsOK(ecode4)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16256 }
16257 arg4 = static_cast< byte >(val4);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 wxString *arg2 = 0 ;
16275 wxString *arg3 = 0 ;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 bool temp2 = false ;
16279 bool temp3 = false ;
16280 PyObject * obj0 = 0 ;
16281 PyObject * obj1 = 0 ;
16282 PyObject * obj2 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *) "name",(char *) "value", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16291 }
16292 arg1 = reinterpret_cast< wxImage * >(argp1);
16293 {
16294 arg2 = wxString_in_helper(obj1);
16295 if (arg2 == NULL) SWIG_fail;
16296 temp2 = true;
16297 }
16298 {
16299 arg3 = wxString_in_helper(obj2);
16300 if (arg3 == NULL) SWIG_fail;
16301 temp3 = true;
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_Py_Void();
16310 {
16311 if (temp2)
16312 delete arg2;
16313 }
16314 {
16315 if (temp3)
16316 delete arg3;
16317 }
16318 return resultobj;
16319 fail:
16320 {
16321 if (temp2)
16322 delete arg2;
16323 }
16324 {
16325 if (temp3)
16326 delete arg3;
16327 }
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxImage *arg1 = (wxImage *) 0 ;
16335 wxString *arg2 = 0 ;
16336 int arg3 ;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 bool temp2 = false ;
16340 int val3 ;
16341 int ecode3 = 0 ;
16342 PyObject * obj0 = 0 ;
16343 PyObject * obj1 = 0 ;
16344 PyObject * obj2 = 0 ;
16345 char * kwnames[] = {
16346 (char *) "self",(char *) "name",(char *) "value", NULL
16347 };
16348
16349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16353 }
16354 arg1 = reinterpret_cast< wxImage * >(argp1);
16355 {
16356 arg2 = wxString_in_helper(obj1);
16357 if (arg2 == NULL) SWIG_fail;
16358 temp2 = true;
16359 }
16360 ecode3 = SWIG_AsVal_int(obj2, &val3);
16361 if (!SWIG_IsOK(ecode3)) {
16362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16363 }
16364 arg3 = static_cast< int >(val3);
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetOption((wxString const &)*arg2,arg3);
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 resultobj = SWIG_Py_Void();
16372 {
16373 if (temp2)
16374 delete arg2;
16375 }
16376 return resultobj;
16377 fail:
16378 {
16379 if (temp2)
16380 delete arg2;
16381 }
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxImage *arg1 = (wxImage *) 0 ;
16389 wxString *arg2 = 0 ;
16390 wxString result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 bool temp2 = false ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "name", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16404 }
16405 arg1 = reinterpret_cast< wxImage * >(argp1);
16406 {
16407 arg2 = wxString_in_helper(obj1);
16408 if (arg2 == NULL) SWIG_fail;
16409 temp2 = true;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 #if wxUSE_UNICODE
16419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16420 #else
16421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16422 #endif
16423 }
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxImage *arg1 = (wxImage *) 0 ;
16441 wxString *arg2 = 0 ;
16442 int result;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 bool temp2 = false ;
16446 PyObject * obj0 = 0 ;
16447 PyObject * obj1 = 0 ;
16448 char * kwnames[] = {
16449 (char *) "self",(char *) "name", NULL
16450 };
16451
16452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16456 }
16457 arg1 = reinterpret_cast< wxImage * >(argp1);
16458 {
16459 arg2 = wxString_in_helper(obj1);
16460 if (arg2 == NULL) SWIG_fail;
16461 temp2 = true;
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16466 wxPyEndAllowThreads(__tstate);
16467 if (PyErr_Occurred()) SWIG_fail;
16468 }
16469 resultobj = SWIG_From_int(static_cast< int >(result));
16470 {
16471 if (temp2)
16472 delete arg2;
16473 }
16474 return resultobj;
16475 fail:
16476 {
16477 if (temp2)
16478 delete arg2;
16479 }
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxImage *arg1 = (wxImage *) 0 ;
16487 wxString *arg2 = 0 ;
16488 bool result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 bool temp2 = false ;
16492 PyObject * obj0 = 0 ;
16493 PyObject * obj1 = 0 ;
16494 char * kwnames[] = {
16495 (char *) "self",(char *) "name", NULL
16496 };
16497
16498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16502 }
16503 arg1 = reinterpret_cast< wxImage * >(argp1);
16504 {
16505 arg2 = wxString_in_helper(obj1);
16506 if (arg2 == NULL) SWIG_fail;
16507 temp2 = true;
16508 }
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16517 }
16518 {
16519 if (temp2)
16520 delete arg2;
16521 }
16522 return resultobj;
16523 fail:
16524 {
16525 if (temp2)
16526 delete arg2;
16527 }
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImage *arg1 = (wxImage *) 0 ;
16535 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16536 unsigned long result;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 unsigned long val2 ;
16540 int ecode2 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "stopafter", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 if (obj1) {
16554 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16557 }
16558 arg2 = static_cast< unsigned long >(val2);
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 result = (unsigned long)(arg1)->CountColours(arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxImageHistogram *arg2 = 0 ;
16577 unsigned long result;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 void *argp2 = 0 ;
16581 int res2 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "h", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16595 if (!SWIG_IsOK(res2)) {
16596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16597 }
16598 if (!argp2) {
16599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16600 }
16601 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj = 0;
16617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16618 void *argp1 = 0 ;
16619 int res1 = 0 ;
16620 PyObject * obj0 = 0 ;
16621 char * kwnames[] = {
16622 (char *) "handler", NULL
16623 };
16624
16625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16627 if (!SWIG_IsOK(res1)) {
16628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16629 }
16630 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 wxImage::AddHandler(arg1);
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 resultobj = SWIG_Py_Void();
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = 0;
16646 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 PyObject * obj0 = 0 ;
16650 char * kwnames[] = {
16651 (char *) "handler", NULL
16652 };
16653
16654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16658 }
16659 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 wxImage::InsertHandler(arg1);
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_Py_Void();
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj = 0;
16675 wxString *arg1 = 0 ;
16676 bool result;
16677 bool temp1 = false ;
16678 PyObject * obj0 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "name", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16684 {
16685 arg1 = wxString_in_helper(obj0);
16686 if (arg1 == NULL) SWIG_fail;
16687 temp1 = true;
16688 }
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 {
16696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16697 }
16698 {
16699 if (temp1)
16700 delete arg1;
16701 }
16702 return resultobj;
16703 fail:
16704 {
16705 if (temp1)
16706 delete arg1;
16707 }
16708 return NULL;
16709 }
16710
16711
16712 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16713 PyObject *resultobj = 0;
16714 PyObject *result = 0 ;
16715
16716 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (PyObject *)wxImage_GetHandlers();
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = result;
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731 PyObject *resultobj = 0;
16732 wxString result;
16733
16734 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = wxImage::GetImageExtWildcard();
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 #if wxUSE_UNICODE
16743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16744 #else
16745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16746 #endif
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj = 0;
16756 wxImage *arg1 = (wxImage *) 0 ;
16757 int arg2 = (int) -1 ;
16758 wxBitmap result;
16759 void *argp1 = 0 ;
16760 int res1 = 0 ;
16761 int val2 ;
16762 int ecode2 = 0 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 char * kwnames[] = {
16766 (char *) "self",(char *) "depth", NULL
16767 };
16768
16769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16771 if (!SWIG_IsOK(res1)) {
16772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16773 }
16774 arg1 = reinterpret_cast< wxImage * >(argp1);
16775 if (obj1) {
16776 ecode2 = SWIG_AsVal_int(obj1, &val2);
16777 if (!SWIG_IsOK(ecode2)) {
16778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16779 }
16780 arg2 = static_cast< int >(val2);
16781 }
16782 {
16783 if (!wxPyCheckForApp()) SWIG_fail;
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = wxImage_ConvertToBitmap(arg1,arg2);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 byte arg2 ;
16800 byte arg3 ;
16801 byte arg4 ;
16802 wxBitmap result;
16803 void *argp1 = 0 ;
16804 int res1 = 0 ;
16805 unsigned char val2 ;
16806 int ecode2 = 0 ;
16807 unsigned char val3 ;
16808 int ecode3 = 0 ;
16809 unsigned char val4 ;
16810 int ecode4 = 0 ;
16811 PyObject * obj0 = 0 ;
16812 PyObject * obj1 = 0 ;
16813 PyObject * obj2 = 0 ;
16814 PyObject * obj3 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16823 }
16824 arg1 = reinterpret_cast< wxImage * >(argp1);
16825 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16828 }
16829 arg2 = static_cast< byte >(val2);
16830 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16831 if (!SWIG_IsOK(ecode3)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16833 }
16834 arg3 = static_cast< byte >(val3);
16835 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16836 if (!SWIG_IsOK(ecode4)) {
16837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16838 }
16839 arg4 = static_cast< byte >(val4);
16840 {
16841 if (!wxPyCheckForApp()) SWIG_fail;
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj = 0;
16856 wxImage *arg1 = (wxImage *) 0 ;
16857 double arg2 ;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 double val2 ;
16861 int ecode2 = 0 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "angle", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16872 }
16873 arg1 = reinterpret_cast< wxImage * >(argp1);
16874 ecode2 = SWIG_AsVal_double(obj1, &val2);
16875 if (!SWIG_IsOK(ecode2)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16877 }
16878 arg2 = static_cast< double >(val2);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 (arg1)->RotateHue(arg2);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_Py_Void();
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxImage_RGBValue arg1 ;
16895 wxImage_HSVValue result;
16896 void *argp1 ;
16897 int res1 = 0 ;
16898 PyObject * obj0 = 0 ;
16899 char * kwnames[] = {
16900 (char *) "rgb", NULL
16901 };
16902
16903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16904 {
16905 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16908 }
16909 if (!argp1) {
16910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16911 } else {
16912 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16913 arg1 = *temp;
16914 if (SWIG_IsNewObj(res1)) delete temp;
16915 }
16916 }
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 result = wxImage::RGBtoHSV(arg1);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj = 0;
16932 wxImage_HSVValue arg1 ;
16933 wxImage_RGBValue result;
16934 void *argp1 ;
16935 int res1 = 0 ;
16936 PyObject * obj0 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "hsv", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16942 {
16943 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16946 }
16947 if (!argp1) {
16948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16949 } else {
16950 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16951 arg1 = *temp;
16952 if (SWIG_IsNewObj(res1)) delete temp;
16953 }
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = wxImage::HSVtoRGB(arg1);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16969 PyObject *obj;
16970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16971 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16972 return SWIG_Py_Void();
16973 }
16974
16975 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16976 return SWIG_Python_InitShadowInstance(args);
16977 }
16978
16979 SWIGINTERN int NullImage_set(PyObject *) {
16980 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16981 return 1;
16982 }
16983
16984
16985 SWIGINTERN PyObject *NullImage_get(void) {
16986 PyObject *pyobj = 0;
16987
16988 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16989 return pyobj;
16990 }
16991
16992
16993 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16995 return 1;
16996 }
16997
16998
16999 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17000 PyObject *pyobj = 0;
17001
17002 {
17003 #if wxUSE_UNICODE
17004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17005 #else
17006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17007 #endif
17008 }
17009 return pyobj;
17010 }
17011
17012
17013 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17015 return 1;
17016 }
17017
17018
17019 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17020 PyObject *pyobj = 0;
17021
17022 {
17023 #if wxUSE_UNICODE
17024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17025 #else
17026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17027 #endif
17028 }
17029 return pyobj;
17030 }
17031
17032
17033 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17035 return 1;
17036 }
17037
17038
17039 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17040 PyObject *pyobj = 0;
17041
17042 {
17043 #if wxUSE_UNICODE
17044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17045 #else
17046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17047 #endif
17048 }
17049 return pyobj;
17050 }
17051
17052
17053 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17055 return 1;
17056 }
17057
17058
17059 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17060 PyObject *pyobj = 0;
17061
17062 {
17063 #if wxUSE_UNICODE
17064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17065 #else
17066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17067 #endif
17068 }
17069 return pyobj;
17070 }
17071
17072
17073 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17075 return 1;
17076 }
17077
17078
17079 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17080 PyObject *pyobj = 0;
17081
17082 {
17083 #if wxUSE_UNICODE
17084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17085 #else
17086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17087 #endif
17088 }
17089 return pyobj;
17090 }
17091
17092
17093 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17095 return 1;
17096 }
17097
17098
17099 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17100 PyObject *pyobj = 0;
17101
17102 {
17103 #if wxUSE_UNICODE
17104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17105 #else
17106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17107 #endif
17108 }
17109 return pyobj;
17110 }
17111
17112
17113 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17114 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17115 return 1;
17116 }
17117
17118
17119 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17120 PyObject *pyobj = 0;
17121
17122 {
17123 #if wxUSE_UNICODE
17124 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17125 #else
17126 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17127 #endif
17128 }
17129 return pyobj;
17130 }
17131
17132
17133 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17134 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17135 return 1;
17136 }
17137
17138
17139 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17140 PyObject *pyobj = 0;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17154 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17155 return 1;
17156 }
17157
17158
17159 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17160 PyObject *pyobj = 0;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17174 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17175 return 1;
17176 }
17177
17178
17179 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17180 PyObject *pyobj = 0;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17194 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17195 return 1;
17196 }
17197
17198
17199 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17200 PyObject *pyobj = 0;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17214 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17215 return 1;
17216 }
17217
17218
17219 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17220 PyObject *pyobj = 0;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17234 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17235 return 1;
17236 }
17237
17238
17239 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17240 PyObject *pyobj = 0;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17254 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17255 return 1;
17256 }
17257
17258
17259 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17260 PyObject *pyobj = 0;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17274 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17275 return 1;
17276 }
17277
17278
17279 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17280 PyObject *pyobj = 0;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 PyObject *resultobj = 0;
17295 wxBMPHandler *result = 0 ;
17296
17297 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (wxBMPHandler *)new wxBMPHandler();
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17312 PyObject *obj;
17313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17314 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17315 return SWIG_Py_Void();
17316 }
17317
17318 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 return SWIG_Python_InitShadowInstance(args);
17320 }
17321
17322 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 wxICOHandler *result = 0 ;
17325
17326 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (wxICOHandler *)new wxICOHandler();
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17341 PyObject *obj;
17342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17343 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17344 return SWIG_Py_Void();
17345 }
17346
17347 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 return SWIG_Python_InitShadowInstance(args);
17349 }
17350
17351 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 PyObject *resultobj = 0;
17353 wxCURHandler *result = 0 ;
17354
17355 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (wxCURHandler *)new wxCURHandler();
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17370 PyObject *obj;
17371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17372 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17373 return SWIG_Py_Void();
17374 }
17375
17376 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 return SWIG_Python_InitShadowInstance(args);
17378 }
17379
17380 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 PyObject *resultobj = 0;
17382 wxANIHandler *result = 0 ;
17383
17384 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (wxANIHandler *)new wxANIHandler();
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17399 PyObject *obj;
17400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17401 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17402 return SWIG_Py_Void();
17403 }
17404
17405 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17406 return SWIG_Python_InitShadowInstance(args);
17407 }
17408
17409 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 PyObject *resultobj = 0;
17411 wxPNGHandler *result = 0 ;
17412
17413 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17414 {
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (wxPNGHandler *)new wxPNGHandler();
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17421 return resultobj;
17422 fail:
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 PyObject *obj;
17429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17430 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17431 return SWIG_Py_Void();
17432 }
17433
17434 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17435 return SWIG_Python_InitShadowInstance(args);
17436 }
17437
17438 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *resultobj = 0;
17440 wxGIFHandler *result = 0 ;
17441
17442 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (wxGIFHandler *)new wxGIFHandler();
17446 wxPyEndAllowThreads(__tstate);
17447 if (PyErr_Occurred()) SWIG_fail;
17448 }
17449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17450 return resultobj;
17451 fail:
17452 return NULL;
17453 }
17454
17455
17456 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17457 PyObject *obj;
17458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17459 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17460 return SWIG_Py_Void();
17461 }
17462
17463 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 return SWIG_Python_InitShadowInstance(args);
17465 }
17466
17467 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *resultobj = 0;
17469 wxPCXHandler *result = 0 ;
17470
17471 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (wxPCXHandler *)new wxPCXHandler();
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *obj;
17487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17488 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17489 return SWIG_Py_Void();
17490 }
17491
17492 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 return SWIG_Python_InitShadowInstance(args);
17494 }
17495
17496 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 PyObject *resultobj = 0;
17498 wxJPEGHandler *result = 0 ;
17499
17500 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxJPEGHandler *)new wxJPEGHandler();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *obj;
17516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17517 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17518 return SWIG_Py_Void();
17519 }
17520
17521 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 return SWIG_Python_InitShadowInstance(args);
17523 }
17524
17525 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxPNMHandler *result = 0 ;
17528
17529 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxPNMHandler *)new wxPNMHandler();
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17544 PyObject *obj;
17545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17547 return SWIG_Py_Void();
17548 }
17549
17550 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 return SWIG_Python_InitShadowInstance(args);
17552 }
17553
17554 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *resultobj = 0;
17556 wxXPMHandler *result = 0 ;
17557
17558 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 result = (wxXPMHandler *)new wxXPMHandler();
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *obj;
17574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17575 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17576 return SWIG_Py_Void();
17577 }
17578
17579 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 return SWIG_Python_InitShadowInstance(args);
17581 }
17582
17583 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17584 PyObject *resultobj = 0;
17585 wxTIFFHandler *result = 0 ;
17586
17587 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxTIFFHandler *)new wxTIFFHandler();
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *obj;
17603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17604 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17605 return SWIG_Py_Void();
17606 }
17607
17608 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 return SWIG_Python_InitShadowInstance(args);
17610 }
17611
17612 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj = 0;
17614 wxImage *arg1 = 0 ;
17615 wxImage *arg2 = 0 ;
17616 int arg3 = (int) 236 ;
17617 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17618 bool result;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 void *argp2 = 0 ;
17622 int res2 = 0 ;
17623 int val3 ;
17624 int ecode3 = 0 ;
17625 int val4 ;
17626 int ecode4 = 0 ;
17627 PyObject * obj0 = 0 ;
17628 PyObject * obj1 = 0 ;
17629 PyObject * obj2 = 0 ;
17630 PyObject * obj3 = 0 ;
17631 char * kwnames[] = {
17632 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17633 };
17634
17635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17636 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17637 if (!SWIG_IsOK(res1)) {
17638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17639 }
17640 if (!argp1) {
17641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17642 }
17643 arg1 = reinterpret_cast< wxImage * >(argp1);
17644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17645 if (!SWIG_IsOK(res2)) {
17646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17647 }
17648 if (!argp2) {
17649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17650 }
17651 arg2 = reinterpret_cast< wxImage * >(argp2);
17652 if (obj2) {
17653 ecode3 = SWIG_AsVal_int(obj2, &val3);
17654 if (!SWIG_IsOK(ecode3)) {
17655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17656 }
17657 arg3 = static_cast< int >(val3);
17658 }
17659 if (obj3) {
17660 ecode4 = SWIG_AsVal_int(obj3, &val4);
17661 if (!SWIG_IsOK(ecode4)) {
17662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17663 }
17664 arg4 = static_cast< int >(val4);
17665 }
17666 {
17667 PyThreadState* __tstate = wxPyBeginAllowThreads();
17668 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17682 PyObject *obj;
17683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17684 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17685 return SWIG_Py_Void();
17686 }
17687
17688 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *result = 0 ;
17691
17692 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxEvtHandler *)new wxEvtHandler();
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17700 return resultobj;
17701 fail:
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17709 wxEvtHandler *result = 0 ;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 PyObject *swig_obj[1] ;
17713
17714 if (!args) SWIG_fail;
17715 swig_obj[0] = args;
17716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17717 if (!SWIG_IsOK(res1)) {
17718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17719 }
17720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 {
17728 resultobj = wxPyMake_wxObject(result, 0);
17729 }
17730 return resultobj;
17731 fail:
17732 return NULL;
17733 }
17734
17735
17736 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17739 wxEvtHandler *result = 0 ;
17740 void *argp1 = 0 ;
17741 int res1 = 0 ;
17742 PyObject *swig_obj[1] ;
17743
17744 if (!args) SWIG_fail;
17745 swig_obj[0] = args;
17746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17747 if (!SWIG_IsOK(res1)) {
17748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17749 }
17750 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 resultobj = wxPyMake_wxObject(result, 0);
17759 }
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj = 0;
17768 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17769 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 void *argp2 = 0 ;
17773 int res2 = 0 ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "handler", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17784 }
17785 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17787 if (!SWIG_IsOK(res2)) {
17788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17789 }
17790 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 (arg1)->SetNextHandler(arg2);
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 resultobj = SWIG_Py_Void();
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj = 0;
17806 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17807 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 void *argp2 = 0 ;
17811 int res2 = 0 ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "handler", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17822 }
17823 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17825 if (!SWIG_IsOK(res2)) {
17826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17827 }
17828 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 (arg1)->SetPreviousHandler(arg2);
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_Py_Void();
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 bool result;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17855 }
17856 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)(arg1)->GetEvtHandlerEnabled();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 {
17864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj = 0;
17874 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17875 bool arg2 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 bool val2 ;
17879 int ecode2 = 0 ;
17880 PyObject * obj0 = 0 ;
17881 PyObject * obj1 = 0 ;
17882 char * kwnames[] = {
17883 (char *) "self",(char *) "enabled", NULL
17884 };
17885
17886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17890 }
17891 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17893 if (!SWIG_IsOK(ecode2)) {
17894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17895 }
17896 arg2 = static_cast< bool >(val2);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->SetEvtHandlerEnabled(arg2);
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 wxEvent *arg2 = 0 ;
17914 bool result;
17915 void *argp1 = 0 ;
17916 int res1 = 0 ;
17917 void *argp2 = 0 ;
17918 int res2 = 0 ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 char * kwnames[] = {
17922 (char *) "self",(char *) "event", NULL
17923 };
17924
17925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17932 if (!SWIG_IsOK(res2)) {
17933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17934 }
17935 if (!argp2) {
17936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17937 }
17938 arg2 = reinterpret_cast< wxEvent * >(argp2);
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 result = (bool)(arg1)->ProcessEvent(*arg2);
17942 wxPyEndAllowThreads(__tstate);
17943 if (PyErr_Occurred()) SWIG_fail;
17944 }
17945 {
17946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17947 }
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj = 0;
17956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17957 wxEvent *arg2 = 0 ;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 void *argp2 = 0 ;
17961 int res2 = 0 ;
17962 PyObject * obj0 = 0 ;
17963 PyObject * obj1 = 0 ;
17964 char * kwnames[] = {
17965 (char *) "self",(char *) "event", NULL
17966 };
17967
17968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17970 if (!SWIG_IsOK(res1)) {
17971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17972 }
17973 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17975 if (!SWIG_IsOK(res2)) {
17976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17977 }
17978 if (!argp2) {
17979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17980 }
17981 arg2 = reinterpret_cast< wxEvent * >(argp2);
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 (arg1)->AddPendingEvent(*arg2);
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_Py_Void();
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *resultobj = 0;
17997 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject *swig_obj[1] ;
18001
18002 if (!args) SWIG_fail;
18003 swig_obj[0] = args;
18004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18007 }
18008 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 (arg1)->ProcessPendingEvents();
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_Py_Void();
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj = 0;
18024 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18025 int arg2 ;
18026 int arg3 ;
18027 int arg4 ;
18028 PyObject *arg5 = (PyObject *) 0 ;
18029 void *argp1 = 0 ;
18030 int res1 = 0 ;
18031 int val2 ;
18032 int ecode2 = 0 ;
18033 int val3 ;
18034 int ecode3 = 0 ;
18035 int val4 ;
18036 int ecode4 = 0 ;
18037 PyObject * obj0 = 0 ;
18038 PyObject * obj1 = 0 ;
18039 PyObject * obj2 = 0 ;
18040 PyObject * obj3 = 0 ;
18041 PyObject * obj4 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18050 }
18051 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18052 ecode2 = SWIG_AsVal_int(obj1, &val2);
18053 if (!SWIG_IsOK(ecode2)) {
18054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18055 }
18056 arg2 = static_cast< int >(val2);
18057 ecode3 = SWIG_AsVal_int(obj2, &val3);
18058 if (!SWIG_IsOK(ecode3)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18060 }
18061 arg3 = static_cast< int >(val3);
18062 ecode4 = SWIG_AsVal_int(obj3, &val4);
18063 if (!SWIG_IsOK(ecode4)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18065 }
18066 arg4 = static_cast< int >(val4);
18067 arg5 = obj4;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 resultobj = SWIG_Py_Void();
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18084 int arg2 ;
18085 int arg3 = (int) -1 ;
18086 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18087 bool result;
18088 void *argp1 = 0 ;
18089 int res1 = 0 ;
18090 int val2 ;
18091 int ecode2 = 0 ;
18092 int val3 ;
18093 int ecode3 = 0 ;
18094 int val4 ;
18095 int ecode4 = 0 ;
18096 PyObject * obj0 = 0 ;
18097 PyObject * obj1 = 0 ;
18098 PyObject * obj2 = 0 ;
18099 PyObject * obj3 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18108 }
18109 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18110 ecode2 = SWIG_AsVal_int(obj1, &val2);
18111 if (!SWIG_IsOK(ecode2)) {
18112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18113 }
18114 arg2 = static_cast< int >(val2);
18115 if (obj2) {
18116 ecode3 = SWIG_AsVal_int(obj2, &val3);
18117 if (!SWIG_IsOK(ecode3)) {
18118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18119 }
18120 arg3 = static_cast< int >(val3);
18121 }
18122 if (obj3) {
18123 ecode4 = SWIG_AsVal_int(obj3, &val4);
18124 if (!SWIG_IsOK(ecode4)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18126 }
18127 arg4 = static_cast< wxEventType >(val4);
18128 }
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj = 0;
18146 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18147 PyObject *arg2 = (PyObject *) 0 ;
18148 bool arg3 = (bool) true ;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 bool val3 ;
18152 int ecode3 = 0 ;
18153 PyObject * obj0 = 0 ;
18154 PyObject * obj1 = 0 ;
18155 PyObject * obj2 = 0 ;
18156 char * kwnames[] = {
18157 (char *) "self",(char *) "_self",(char *) "incref", NULL
18158 };
18159
18160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18162 if (!SWIG_IsOK(res1)) {
18163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18164 }
18165 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18166 arg2 = obj1;
18167 if (obj2) {
18168 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18169 if (!SWIG_IsOK(ecode3)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18171 }
18172 arg3 = static_cast< bool >(val3);
18173 }
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = SWIG_Py_Void();
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 PyObject *obj;
18189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18190 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18191 return SWIG_Py_Void();
18192 }
18193
18194 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18195 return SWIG_Python_InitShadowInstance(args);
18196 }
18197
18198 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxEventType result;
18201
18202 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (wxEventType)wxNewEventType();
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 resultobj = SWIG_From_int(static_cast< int >(result));
18210 return resultobj;
18211 fail:
18212 return NULL;
18213 }
18214
18215
18216 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18217 PyObject *resultobj = 0;
18218 wxEvent *arg1 = (wxEvent *) 0 ;
18219 void *argp1 = 0 ;
18220 int res1 = 0 ;
18221 PyObject *swig_obj[1] ;
18222
18223 if (!args) SWIG_fail;
18224 swig_obj[0] = args;
18225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 delete arg1;
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 resultobj = SWIG_Py_Void();
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj = 0;
18246 wxEvent *arg1 = (wxEvent *) 0 ;
18247 wxEventType arg2 ;
18248 void *argp1 = 0 ;
18249 int res1 = 0 ;
18250 int val2 ;
18251 int ecode2 = 0 ;
18252 PyObject * obj0 = 0 ;
18253 PyObject * obj1 = 0 ;
18254 char * kwnames[] = {
18255 (char *) "self",(char *) "typ", NULL
18256 };
18257
18258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18260 if (!SWIG_IsOK(res1)) {
18261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18262 }
18263 arg1 = reinterpret_cast< wxEvent * >(argp1);
18264 ecode2 = SWIG_AsVal_int(obj1, &val2);
18265 if (!SWIG_IsOK(ecode2)) {
18266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18267 }
18268 arg2 = static_cast< wxEventType >(val2);
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 (arg1)->SetEventType(arg2);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_Py_Void();
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxEvent *arg1 = (wxEvent *) 0 ;
18285 wxEventType result;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = SWIG_From_int(static_cast< int >(result));
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18311 PyObject *resultobj = 0;
18312 wxEvent *arg1 = (wxEvent *) 0 ;
18313 wxObject *result = 0 ;
18314 void *argp1 = 0 ;
18315 int res1 = 0 ;
18316 PyObject *swig_obj[1] ;
18317
18318 if (!args) SWIG_fail;
18319 swig_obj[0] = args;
18320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18321 if (!SWIG_IsOK(res1)) {
18322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18323 }
18324 arg1 = reinterpret_cast< wxEvent * >(argp1);
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 resultobj = wxPyMake_wxObject(result, (bool)0);
18333 }
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj = 0;
18342 wxEvent *arg1 = (wxEvent *) 0 ;
18343 wxObject *arg2 = (wxObject *) 0 ;
18344 void *argp1 = 0 ;
18345 int res1 = 0 ;
18346 void *argp2 = 0 ;
18347 int res2 = 0 ;
18348 PyObject * obj0 = 0 ;
18349 PyObject * obj1 = 0 ;
18350 char * kwnames[] = {
18351 (char *) "self",(char *) "obj", NULL
18352 };
18353
18354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18356 if (!SWIG_IsOK(res1)) {
18357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18358 }
18359 arg1 = reinterpret_cast< wxEvent * >(argp1);
18360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18361 if (!SWIG_IsOK(res2)) {
18362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18363 }
18364 arg2 = reinterpret_cast< wxObject * >(argp2);
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 (arg1)->SetEventObject(arg2);
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 resultobj = SWIG_Py_Void();
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18379 PyObject *resultobj = 0;
18380 wxEvent *arg1 = (wxEvent *) 0 ;
18381 long result;
18382 void *argp1 = 0 ;
18383 int res1 = 0 ;
18384 PyObject *swig_obj[1] ;
18385
18386 if (!args) SWIG_fail;
18387 swig_obj[0] = args;
18388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18389 if (!SWIG_IsOK(res1)) {
18390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18391 }
18392 arg1 = reinterpret_cast< wxEvent * >(argp1);
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_From_long(static_cast< long >(result));
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj = 0;
18408 wxEvent *arg1 = (wxEvent *) 0 ;
18409 long arg2 = (long) 0 ;
18410 void *argp1 = 0 ;
18411 int res1 = 0 ;
18412 long val2 ;
18413 int ecode2 = 0 ;
18414 PyObject * obj0 = 0 ;
18415 PyObject * obj1 = 0 ;
18416 char * kwnames[] = {
18417 (char *) "self",(char *) "ts", NULL
18418 };
18419
18420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18424 }
18425 arg1 = reinterpret_cast< wxEvent * >(argp1);
18426 if (obj1) {
18427 ecode2 = SWIG_AsVal_long(obj1, &val2);
18428 if (!SWIG_IsOK(ecode2)) {
18429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18430 }
18431 arg2 = static_cast< long >(val2);
18432 }
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 (arg1)->SetTimestamp(arg2);
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 resultobj = SWIG_Py_Void();
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18447 PyObject *resultobj = 0;
18448 wxEvent *arg1 = (wxEvent *) 0 ;
18449 int result;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 PyObject *swig_obj[1] ;
18453
18454 if (!args) SWIG_fail;
18455 swig_obj[0] = args;
18456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (int)((wxEvent const *)arg1)->GetId();
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_From_int(static_cast< int >(result));
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj = 0;
18476 wxEvent *arg1 = (wxEvent *) 0 ;
18477 int arg2 ;
18478 void *argp1 = 0 ;
18479 int res1 = 0 ;
18480 int val2 ;
18481 int ecode2 = 0 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 char * kwnames[] = {
18485 (char *) "self",(char *) "Id", NULL
18486 };
18487
18488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 ecode2 = SWIG_AsVal_int(obj1, &val2);
18495 if (!SWIG_IsOK(ecode2)) {
18496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18497 }
18498 arg2 = static_cast< int >(val2);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 (arg1)->SetId(arg2);
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_Py_Void();
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 bool result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 {
18534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18535 }
18536 return resultobj;
18537 fail:
18538 return NULL;
18539 }
18540
18541
18542 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj = 0;
18544 wxEvent *arg1 = (wxEvent *) 0 ;
18545 bool arg2 = (bool) true ;
18546 void *argp1 = 0 ;
18547 int res1 = 0 ;
18548 bool val2 ;
18549 int ecode2 = 0 ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "self",(char *) "skip", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18560 }
18561 arg1 = reinterpret_cast< wxEvent * >(argp1);
18562 if (obj1) {
18563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18564 if (!SWIG_IsOK(ecode2)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18566 }
18567 arg2 = static_cast< bool >(val2);
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 (arg1)->Skip(arg2);
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 resultobj = SWIG_Py_Void();
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18583 PyObject *resultobj = 0;
18584 wxEvent *arg1 = (wxEvent *) 0 ;
18585 bool result;
18586 void *argp1 = 0 ;
18587 int res1 = 0 ;
18588 PyObject *swig_obj[1] ;
18589
18590 if (!args) SWIG_fail;
18591 swig_obj[0] = args;
18592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18593 if (!SWIG_IsOK(res1)) {
18594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18595 }
18596 arg1 = reinterpret_cast< wxEvent * >(argp1);
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 {
18604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18605 }
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18613 PyObject *resultobj = 0;
18614 wxEvent *arg1 = (wxEvent *) 0 ;
18615 bool result;
18616 void *argp1 = 0 ;
18617 int res1 = 0 ;
18618 PyObject *swig_obj[1] ;
18619
18620 if (!args) SWIG_fail;
18621 swig_obj[0] = args;
18622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvent * >(argp1);
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18643 PyObject *resultobj = 0;
18644 wxEvent *arg1 = (wxEvent *) 0 ;
18645 int result;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18655 }
18656 arg1 = reinterpret_cast< wxEvent * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (int)(arg1)->StopPropagation();
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 resultobj = SWIG_From_int(static_cast< int >(result));
18664 return resultobj;
18665 fail:
18666 return NULL;
18667 }
18668
18669
18670 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18671 PyObject *resultobj = 0;
18672 wxEvent *arg1 = (wxEvent *) 0 ;
18673 int arg2 ;
18674 void *argp1 = 0 ;
18675 int res1 = 0 ;
18676 int val2 ;
18677 int ecode2 = 0 ;
18678 PyObject * obj0 = 0 ;
18679 PyObject * obj1 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "propagationLevel", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvent * >(argp1);
18690 ecode2 = SWIG_AsVal_int(obj1, &val2);
18691 if (!SWIG_IsOK(ecode2)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18693 }
18694 arg2 = static_cast< int >(val2);
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 (arg1)->ResumePropagation(arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_Py_Void();
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxEvent *arg1 = (wxEvent *) 0 ;
18711 wxEvent *result = 0 ;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxEvent *)(arg1)->Clone();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *obj;
18738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18739 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18740 return SWIG_Py_Void();
18741 }
18742
18743 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj = 0;
18745 wxEvent *arg1 = 0 ;
18746 wxPropagationDisabler *result = 0 ;
18747 void *argp1 = 0 ;
18748 int res1 = 0 ;
18749 PyObject * obj0 = 0 ;
18750 char * kwnames[] = {
18751 (char *) "event", NULL
18752 };
18753
18754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18755 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18756 if (!SWIG_IsOK(res1)) {
18757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18758 }
18759 if (!argp1) {
18760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18761 }
18762 arg1 = reinterpret_cast< wxEvent * >(argp1);
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 PyObject *resultobj = 0;
18778 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18779 void *argp1 = 0 ;
18780 int res1 = 0 ;
18781 PyObject *swig_obj[1] ;
18782
18783 if (!args) SWIG_fail;
18784 swig_obj[0] = args;
18785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18786 if (!SWIG_IsOK(res1)) {
18787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18788 }
18789 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 delete arg1;
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 resultobj = SWIG_Py_Void();
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18805 PyObject *obj;
18806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18807 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18808 return SWIG_Py_Void();
18809 }
18810
18811 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18812 return SWIG_Python_InitShadowInstance(args);
18813 }
18814
18815 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj = 0;
18817 wxEvent *arg1 = 0 ;
18818 wxPropagateOnce *result = 0 ;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject * obj0 = 0 ;
18822 char * kwnames[] = {
18823 (char *) "event", NULL
18824 };
18825
18826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18827 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18830 }
18831 if (!argp1) {
18832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18833 }
18834 arg1 = reinterpret_cast< wxEvent * >(argp1);
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 PyObject *resultobj = 0;
18850 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 PyObject *swig_obj[1] ;
18854
18855 if (!args) SWIG_fail;
18856 swig_obj[0] = args;
18857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18860 }
18861 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 delete arg1;
18865
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 resultobj = SWIG_Py_Void();
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18877 PyObject *obj;
18878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18879 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18880 return SWIG_Py_Void();
18881 }
18882
18883 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18884 return SWIG_Python_InitShadowInstance(args);
18885 }
18886
18887 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj = 0;
18889 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18890 int arg2 = (int) 0 ;
18891 wxCommandEvent *result = 0 ;
18892 int val1 ;
18893 int ecode1 = 0 ;
18894 int val2 ;
18895 int ecode2 = 0 ;
18896 PyObject * obj0 = 0 ;
18897 PyObject * obj1 = 0 ;
18898 char * kwnames[] = {
18899 (char *) "commandType",(char *) "winid", NULL
18900 };
18901
18902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18903 if (obj0) {
18904 ecode1 = SWIG_AsVal_int(obj0, &val1);
18905 if (!SWIG_IsOK(ecode1)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18907 }
18908 arg1 = static_cast< wxEventType >(val1);
18909 }
18910 if (obj1) {
18911 ecode2 = SWIG_AsVal_int(obj1, &val2);
18912 if (!SWIG_IsOK(ecode2)) {
18913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18914 }
18915 arg2 = static_cast< int >(val2);
18916 }
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 int result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_From_int(static_cast< int >(result));
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj = 0;
18960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18961 wxString *arg2 = 0 ;
18962 void *argp1 = 0 ;
18963 int res1 = 0 ;
18964 bool temp2 = false ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char * kwnames[] = {
18968 (char *) "self",(char *) "s", NULL
18969 };
18970
18971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18973 if (!SWIG_IsOK(res1)) {
18974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18975 }
18976 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18977 {
18978 arg2 = wxString_in_helper(obj1);
18979 if (arg2 == NULL) SWIG_fail;
18980 temp2 = true;
18981 }
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 (arg1)->SetString((wxString const &)*arg2);
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = SWIG_Py_Void();
18989 {
18990 if (temp2)
18991 delete arg2;
18992 }
18993 return resultobj;
18994 fail:
18995 {
18996 if (temp2)
18997 delete arg2;
18998 }
18999 return NULL;
19000 }
19001
19002
19003 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19004 PyObject *resultobj = 0;
19005 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19006 wxString result;
19007 void *argp1 = 0 ;
19008 int res1 = 0 ;
19009 PyObject *swig_obj[1] ;
19010
19011 if (!args) SWIG_fail;
19012 swig_obj[0] = args;
19013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = ((wxCommandEvent const *)arg1)->GetString();
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 {
19025 #if wxUSE_UNICODE
19026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19027 #else
19028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19029 #endif
19030 }
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19038 PyObject *resultobj = 0;
19039 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19040 bool result;
19041 void *argp1 = 0 ;
19042 int res1 = 0 ;
19043 PyObject *swig_obj[1] ;
19044
19045 if (!args) SWIG_fail;
19046 swig_obj[0] = args;
19047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19050 }
19051 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19055 wxPyEndAllowThreads(__tstate);
19056 if (PyErr_Occurred()) SWIG_fail;
19057 }
19058 {
19059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19060 }
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19070 bool result;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19080 }
19081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 return resultobj;
19092 fail:
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19100 long arg2 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 long val2 ;
19104 int ecode2 = 0 ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "extraLong", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19115 }
19116 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19117 ecode2 = SWIG_AsVal_long(obj1, &val2);
19118 if (!SWIG_IsOK(ecode2)) {
19119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19120 }
19121 arg2 = static_cast< long >(val2);
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->SetExtraLong(arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_Py_Void();
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 PyObject *resultobj = 0;
19137 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19138 long result;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19148 }
19149 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 resultobj = SWIG_From_long(static_cast< long >(result));
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj = 0;
19165 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19166 int arg2 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 int val2 ;
19170 int ecode2 = 0 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char * kwnames[] = {
19174 (char *) "self",(char *) "i", NULL
19175 };
19176
19177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19181 }
19182 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19183 ecode2 = SWIG_AsVal_int(obj1, &val2);
19184 if (!SWIG_IsOK(ecode2)) {
19185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19186 }
19187 arg2 = static_cast< int >(val2);
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 (arg1)->SetInt(arg2);
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 resultobj = SWIG_Py_Void();
19195 return resultobj;
19196 fail:
19197 return NULL;
19198 }
19199
19200
19201 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19202 PyObject *resultobj = 0;
19203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19204 int result;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19214 }
19215 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 resultobj = SWIG_From_int(static_cast< int >(result));
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 PyObject *resultobj = 0;
19231 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19232 PyObject *result = 0 ;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 PyObject *swig_obj[1] ;
19236
19237 if (!args) SWIG_fail;
19238 swig_obj[0] = args;
19239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19242 }
19243 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = result;
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19260 PyObject *arg2 = (PyObject *) 0 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char * kwnames[] = {
19266 (char *) "self",(char *) "clientData", NULL
19267 };
19268
19269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19271 if (!SWIG_IsOK(res1)) {
19272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19273 }
19274 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19275 arg2 = obj1;
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 wxCommandEvent_SetClientData(arg1,arg2);
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 resultobj = SWIG_Py_Void();
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19290 PyObject *resultobj = 0;
19291 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19292 wxEvent *result = 0 ;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 PyObject *swig_obj[1] ;
19296
19297 if (!args) SWIG_fail;
19298 swig_obj[0] = args;
19299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19302 }
19303 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *obj;
19319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19320 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19321 return SWIG_Py_Void();
19322 }
19323
19324 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 return SWIG_Python_InitShadowInstance(args);
19326 }
19327
19328 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj = 0;
19330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19331 int arg2 = (int) 0 ;
19332 wxNotifyEvent *result = 0 ;
19333 int val1 ;
19334 int ecode1 = 0 ;
19335 int val2 ;
19336 int ecode2 = 0 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "commandType",(char *) "winid", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19344 if (obj0) {
19345 ecode1 = SWIG_AsVal_int(obj0, &val1);
19346 if (!SWIG_IsOK(ecode1)) {
19347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19348 }
19349 arg1 = static_cast< wxEventType >(val1);
19350 }
19351 if (obj1) {
19352 ecode2 = SWIG_AsVal_int(obj1, &val2);
19353 if (!SWIG_IsOK(ecode2)) {
19354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19355 }
19356 arg2 = static_cast< int >(val2);
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19372 PyObject *resultobj = 0;
19373 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 PyObject *swig_obj[1] ;
19377
19378 if (!args) SWIG_fail;
19379 swig_obj[0] = args;
19380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19381 if (!SWIG_IsOK(res1)) {
19382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19383 }
19384 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->Veto();
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19410 }
19411 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 (arg1)->Allow();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_Py_Void();
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19428 bool result;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (bool)(arg1)->IsAllowed();
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 {
19447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19448 }
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19456 PyObject *obj;
19457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19458 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19459 return SWIG_Py_Void();
19460 }
19461
19462 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19463 return SWIG_Python_InitShadowInstance(args);
19464 }
19465
19466 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj = 0;
19468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19469 int arg2 = (int) 0 ;
19470 int arg3 = (int) 0 ;
19471 int arg4 = (int) 0 ;
19472 wxScrollEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 int val3 ;
19478 int ecode3 = 0 ;
19479 int val4 ;
19480 int ecode4 = 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 PyObject * obj2 = 0 ;
19484 PyObject * obj3 = 0 ;
19485 char * kwnames[] = {
19486 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19487 };
19488
19489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19490 if (obj0) {
19491 ecode1 = SWIG_AsVal_int(obj0, &val1);
19492 if (!SWIG_IsOK(ecode1)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19494 }
19495 arg1 = static_cast< wxEventType >(val1);
19496 }
19497 if (obj1) {
19498 ecode2 = SWIG_AsVal_int(obj1, &val2);
19499 if (!SWIG_IsOK(ecode2)) {
19500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19501 }
19502 arg2 = static_cast< int >(val2);
19503 }
19504 if (obj2) {
19505 ecode3 = SWIG_AsVal_int(obj2, &val3);
19506 if (!SWIG_IsOK(ecode3)) {
19507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19508 }
19509 arg3 = static_cast< int >(val3);
19510 }
19511 if (obj3) {
19512 ecode4 = SWIG_AsVal_int(obj3, &val4);
19513 if (!SWIG_IsOK(ecode4)) {
19514 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19515 }
19516 arg4 = static_cast< int >(val4);
19517 }
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19532 PyObject *resultobj = 0;
19533 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19534 int result;
19535 void *argp1 = 0 ;
19536 int res1 = 0 ;
19537 PyObject *swig_obj[1] ;
19538
19539 if (!args) SWIG_fail;
19540 swig_obj[0] = args;
19541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19542 if (!SWIG_IsOK(res1)) {
19543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19544 }
19545 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 resultobj = SWIG_From_int(static_cast< int >(result));
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 PyObject *resultobj = 0;
19561 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19562 int result;
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_wxScrollEvent, 0 | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19572 }
19573 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 resultobj = SWIG_From_int(static_cast< int >(result));
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = 0;
19589 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19590 int arg2 ;
19591 void *argp1 = 0 ;
19592 int res1 = 0 ;
19593 int val2 ;
19594 int ecode2 = 0 ;
19595 PyObject * obj0 = 0 ;
19596 PyObject * obj1 = 0 ;
19597 char * kwnames[] = {
19598 (char *) "self",(char *) "orient", NULL
19599 };
19600
19601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19603 if (!SWIG_IsOK(res1)) {
19604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19605 }
19606 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19607 ecode2 = SWIG_AsVal_int(obj1, &val2);
19608 if (!SWIG_IsOK(ecode2)) {
19609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19610 }
19611 arg2 = static_cast< int >(val2);
19612 {
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 (arg1)->SetOrientation(arg2);
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_Py_Void();
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = 0;
19627 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19628 int arg2 ;
19629 void *argp1 = 0 ;
19630 int res1 = 0 ;
19631 int val2 ;
19632 int ecode2 = 0 ;
19633 PyObject * obj0 = 0 ;
19634 PyObject * obj1 = 0 ;
19635 char * kwnames[] = {
19636 (char *) "self",(char *) "pos", NULL
19637 };
19638
19639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19643 }
19644 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19645 ecode2 = SWIG_AsVal_int(obj1, &val2);
19646 if (!SWIG_IsOK(ecode2)) {
19647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19648 }
19649 arg2 = static_cast< int >(val2);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 (arg1)->SetPosition(arg2);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_Py_Void();
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19664 PyObject *obj;
19665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19666 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19667 return SWIG_Py_Void();
19668 }
19669
19670 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 return SWIG_Python_InitShadowInstance(args);
19672 }
19673
19674 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj = 0;
19676 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19677 int arg2 = (int) 0 ;
19678 int arg3 = (int) 0 ;
19679 wxScrollWinEvent *result = 0 ;
19680 int val1 ;
19681 int ecode1 = 0 ;
19682 int val2 ;
19683 int ecode2 = 0 ;
19684 int val3 ;
19685 int ecode3 = 0 ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 PyObject * obj2 = 0 ;
19689 char * kwnames[] = {
19690 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19691 };
19692
19693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19694 if (obj0) {
19695 ecode1 = SWIG_AsVal_int(obj0, &val1);
19696 if (!SWIG_IsOK(ecode1)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19698 }
19699 arg1 = static_cast< wxEventType >(val1);
19700 }
19701 if (obj1) {
19702 ecode2 = SWIG_AsVal_int(obj1, &val2);
19703 if (!SWIG_IsOK(ecode2)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19705 }
19706 arg2 = static_cast< int >(val2);
19707 }
19708 if (obj2) {
19709 ecode3 = SWIG_AsVal_int(obj2, &val3);
19710 if (!SWIG_IsOK(ecode3)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19712 }
19713 arg3 = static_cast< int >(val3);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 wxMouseEvent *result = 0 ;
19875 int val1 ;
19876 int ecode1 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 char * kwnames[] = {
19879 (char *) "mouseType", NULL
19880 };
19881
19882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19883 if (obj0) {
19884 ecode1 = SWIG_AsVal_int(obj0, &val1);
19885 if (!SWIG_IsOK(ecode1)) {
19886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19887 }
19888 arg1 = static_cast< wxEventType >(val1);
19889 }
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 {
19897 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19898 }
19899 return resultobj;
19900 fail:
19901 return NULL;
19902 }
19903
19904
19905 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19906 PyObject *resultobj = 0;
19907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19908 bool result;
19909 void *argp1 = 0 ;
19910 int res1 = 0 ;
19911 PyObject *swig_obj[1] ;
19912
19913 if (!args) SWIG_fail;
19914 swig_obj[0] = args;
19915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19918 }
19919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 {
19927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19928 }
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = 0;
19937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19938 int arg2 = (int) wxMOUSE_BTN_ANY ;
19939 bool result;
19940 void *argp1 = 0 ;
19941 int res1 = 0 ;
19942 int val2 ;
19943 int ecode2 = 0 ;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 char * kwnames[] = {
19947 (char *) "self",(char *) "but", NULL
19948 };
19949
19950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 if (obj1) {
19957 ecode2 = SWIG_AsVal_int(obj1, &val2);
19958 if (!SWIG_IsOK(ecode2)) {
19959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19960 }
19961 arg2 = static_cast< int >(val2);
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 {
19970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19971 }
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19979 PyObject *resultobj = 0;
19980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19981 int arg2 = (int) wxMOUSE_BTN_ANY ;
19982 bool result;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 int val2 ;
19986 int ecode2 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char * kwnames[] = {
19990 (char *) "self",(char *) "but", NULL
19991 };
19992
19993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19997 }
19998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19999 if (obj1) {
20000 ecode2 = SWIG_AsVal_int(obj1, &val2);
20001 if (!SWIG_IsOK(ecode2)) {
20002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20003 }
20004 arg2 = static_cast< int >(val2);
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 {
20013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20014 }
20015 return resultobj;
20016 fail:
20017 return NULL;
20018 }
20019
20020
20021 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20022 PyObject *resultobj = 0;
20023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20024 int arg2 = (int) wxMOUSE_BTN_ANY ;
20025 bool result;
20026 void *argp1 = 0 ;
20027 int res1 = 0 ;
20028 int val2 ;
20029 int ecode2 = 0 ;
20030 PyObject * obj0 = 0 ;
20031 PyObject * obj1 = 0 ;
20032 char * kwnames[] = {
20033 (char *) "self",(char *) "but", NULL
20034 };
20035
20036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 if (obj1) {
20043 ecode2 = SWIG_AsVal_int(obj1, &val2);
20044 if (!SWIG_IsOK(ecode2)) {
20045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20046 }
20047 arg2 = static_cast< int >(val2);
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 {
20056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20057 }
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj = 0;
20066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20067 int arg2 ;
20068 bool result;
20069 void *argp1 = 0 ;
20070 int res1 = 0 ;
20071 int val2 ;
20072 int ecode2 = 0 ;
20073 PyObject * obj0 = 0 ;
20074 PyObject * obj1 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "self",(char *) "button", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20081 if (!SWIG_IsOK(res1)) {
20082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20083 }
20084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20085 ecode2 = SWIG_AsVal_int(obj1, &val2);
20086 if (!SWIG_IsOK(ecode2)) {
20087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20088 }
20089 arg2 = static_cast< int >(val2);
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 {
20097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20098 }
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj = 0;
20107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20108 int arg2 ;
20109 bool result;
20110 void *argp1 = 0 ;
20111 int res1 = 0 ;
20112 int val2 ;
20113 int ecode2 = 0 ;
20114 PyObject * obj0 = 0 ;
20115 PyObject * obj1 = 0 ;
20116 char * kwnames[] = {
20117 (char *) "self",(char *) "but", NULL
20118 };
20119
20120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20122 if (!SWIG_IsOK(res1)) {
20123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20124 }
20125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20126 ecode2 = SWIG_AsVal_int(obj1, &val2);
20127 if (!SWIG_IsOK(ecode2)) {
20128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20129 }
20130 arg2 = static_cast< int >(val2);
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 {
20138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20139 }
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20149 int result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20159 }
20160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_From_int(static_cast< int >(result));
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *resultobj = 0;
20176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20177 bool result;
20178 void *argp1 = 0 ;
20179 int res1 = 0 ;
20180 PyObject *swig_obj[1] ;
20181
20182 if (!args) SWIG_fail;
20183 swig_obj[0] = args;
20184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20187 }
20188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *resultobj = 0;
20206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 PyObject *swig_obj[1] ;
20211
20212 if (!args) SWIG_fail;
20213 swig_obj[0] = args;
20214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20217 }
20218 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 {
20226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20227 }
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *resultobj = 0;
20236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20237 bool result;
20238 void *argp1 = 0 ;
20239 int res1 = 0 ;
20240 PyObject *swig_obj[1] ;
20241
20242 if (!args) SWIG_fail;
20243 swig_obj[0] = args;
20244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20245 if (!SWIG_IsOK(res1)) {
20246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20247 }
20248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20265 PyObject *resultobj = 0;
20266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20267 bool result;
20268 void *argp1 = 0 ;
20269 int res1 = 0 ;
20270 PyObject *swig_obj[1] ;
20271
20272 if (!args) SWIG_fail;
20273 swig_obj[0] = args;
20274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20277 }
20278 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 {
20286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20287 }
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 PyObject *resultobj = 0;
20296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20297 bool result;
20298 void *argp1 = 0 ;
20299 int res1 = 0 ;
20300 PyObject *swig_obj[1] ;
20301
20302 if (!args) SWIG_fail;
20303 swig_obj[0] = args;
20304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20307 }
20308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20317 }
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 PyObject *resultobj = 0;
20326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20327 bool result;
20328 void *argp1 = 0 ;
20329 int res1 = 0 ;
20330 PyObject *swig_obj[1] ;
20331
20332 if (!args) SWIG_fail;
20333 swig_obj[0] = args;
20334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20335 if (!SWIG_IsOK(res1)) {
20336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20337 }
20338 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20347 }
20348 return resultobj;
20349 fail:
20350 return NULL;
20351 }
20352
20353
20354 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 PyObject *resultobj = 0;
20356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20357 bool result;
20358 void *argp1 = 0 ;
20359 int res1 = 0 ;
20360 PyObject *swig_obj[1] ;
20361
20362 if (!args) SWIG_fail;
20363 swig_obj[0] = args;
20364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20365 if (!SWIG_IsOK(res1)) {
20366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20367 }
20368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20385 PyObject *resultobj = 0;
20386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20387 bool result;
20388 void *argp1 = 0 ;
20389 int res1 = 0 ;
20390 PyObject *swig_obj[1] ;
20391
20392 if (!args) SWIG_fail;
20393 swig_obj[0] = args;
20394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20395 if (!SWIG_IsOK(res1)) {
20396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20397 }
20398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 PyObject *resultobj = 0;
20416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20417 bool result;
20418 void *argp1 = 0 ;
20419 int res1 = 0 ;
20420 PyObject *swig_obj[1] ;
20421
20422 if (!args) SWIG_fail;
20423 swig_obj[0] = args;
20424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20427 }
20428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 {
20436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20437 }
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 PyObject *resultobj = 0;
20446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20447 bool result;
20448 void *argp1 = 0 ;
20449 int res1 = 0 ;
20450 PyObject *swig_obj[1] ;
20451
20452 if (!args) SWIG_fail;
20453 swig_obj[0] = args;
20454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20455 if (!SWIG_IsOK(res1)) {
20456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20457 }
20458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20462 wxPyEndAllowThreads(__tstate);
20463 if (PyErr_Occurred()) SWIG_fail;
20464 }
20465 {
20466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20467 }
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 PyObject *resultobj = 0;
20476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20477 bool result;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20487 }
20488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20492 wxPyEndAllowThreads(__tstate);
20493 if (PyErr_Occurred()) SWIG_fail;
20494 }
20495 {
20496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20505 PyObject *resultobj = 0;
20506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20507 bool result;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject *swig_obj[1] ;
20511
20512 if (!args) SWIG_fail;
20513 swig_obj[0] = args;
20514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20515 if (!SWIG_IsOK(res1)) {
20516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20517 }
20518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20527 }
20528 return resultobj;
20529 fail:
20530 return NULL;
20531 }
20532
20533
20534 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20535 PyObject *resultobj = 0;
20536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20537 bool result;
20538 void *argp1 = 0 ;
20539 int res1 = 0 ;
20540 PyObject *swig_obj[1] ;
20541
20542 if (!args) SWIG_fail;
20543 swig_obj[0] = args;
20544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20545 if (!SWIG_IsOK(res1)) {
20546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20547 }
20548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 {
20556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20565 PyObject *resultobj = 0;
20566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20567 bool result;
20568 void *argp1 = 0 ;
20569 int res1 = 0 ;
20570 PyObject *swig_obj[1] ;
20571
20572 if (!args) SWIG_fail;
20573 swig_obj[0] = args;
20574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20575 if (!SWIG_IsOK(res1)) {
20576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20577 }
20578 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 {
20586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20587 }
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20595 PyObject *resultobj = 0;
20596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20597 bool result;
20598 void *argp1 = 0 ;
20599 int res1 = 0 ;
20600 PyObject *swig_obj[1] ;
20601
20602 if (!args) SWIG_fail;
20603 swig_obj[0] = args;
20604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20605 if (!SWIG_IsOK(res1)) {
20606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20607 }
20608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (bool)(arg1)->LeftIsDown();
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 {
20616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20617 }
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 PyObject *resultobj = 0;
20626 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20627 bool result;
20628 void *argp1 = 0 ;
20629 int res1 = 0 ;
20630 PyObject *swig_obj[1] ;
20631
20632 if (!args) SWIG_fail;
20633 swig_obj[0] = args;
20634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20635 if (!SWIG_IsOK(res1)) {
20636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20637 }
20638 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20639 {
20640 PyThreadState* __tstate = wxPyBeginAllowThreads();
20641 result = (bool)(arg1)->MiddleIsDown();
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20647 }
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655 PyObject *resultobj = 0;
20656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20657 bool result;
20658 void *argp1 = 0 ;
20659 int res1 = 0 ;
20660 PyObject *swig_obj[1] ;
20661
20662 if (!args) SWIG_fail;
20663 swig_obj[0] = args;
20664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20665 if (!SWIG_IsOK(res1)) {
20666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20667 }
20668 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = (bool)(arg1)->RightIsDown();
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 {
20676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20677 }
20678 return resultobj;
20679 fail:
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685 PyObject *resultobj = 0;
20686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20687 bool result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 PyObject *swig_obj[1] ;
20691
20692 if (!args) SWIG_fail;
20693 swig_obj[0] = args;
20694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20695 if (!SWIG_IsOK(res1)) {
20696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20697 }
20698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 bool result;
20718 void *argp1 = 0 ;
20719 int res1 = 0 ;
20720 PyObject *swig_obj[1] ;
20721
20722 if (!args) SWIG_fail;
20723 swig_obj[0] = args;
20724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20725 if (!SWIG_IsOK(res1)) {
20726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20727 }
20728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 PyObject *resultobj = 0;
20746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20747 bool result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 PyObject *swig_obj[1] ;
20751
20752 if (!args) SWIG_fail;
20753 swig_obj[0] = args;
20754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20757 }
20758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 {
20766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20767 }
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20775 PyObject *resultobj = 0;
20776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20777 bool result;
20778 void *argp1 = 0 ;
20779 int res1 = 0 ;
20780 PyObject *swig_obj[1] ;
20781
20782 if (!args) SWIG_fail;
20783 swig_obj[0] = args;
20784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20787 }
20788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20789 {
20790 PyThreadState* __tstate = wxPyBeginAllowThreads();
20791 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20792 wxPyEndAllowThreads(__tstate);
20793 if (PyErr_Occurred()) SWIG_fail;
20794 }
20795 {
20796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805 PyObject *resultobj = 0;
20806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20807 wxPoint result;
20808 void *argp1 = 0 ;
20809 int res1 = 0 ;
20810 PyObject *swig_obj[1] ;
20811
20812 if (!args) SWIG_fail;
20813 swig_obj[0] = args;
20814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20815 if (!SWIG_IsOK(res1)) {
20816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20817 }
20818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (arg1)->GetPosition();
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 long *arg2 = (long *) 0 ;
20836 long *arg3 = (long *) 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 long temp2 ;
20840 int res2 = SWIG_TMPOBJ ;
20841 long temp3 ;
20842 int res3 = SWIG_TMPOBJ ;
20843 PyObject *swig_obj[1] ;
20844
20845 arg2 = &temp2;
20846 arg3 = &temp3;
20847 if (!args) SWIG_fail;
20848 swig_obj[0] = args;
20849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20850 if (!SWIG_IsOK(res1)) {
20851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20852 }
20853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 (arg1)->GetPosition(arg2,arg3);
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 resultobj = SWIG_Py_Void();
20861 if (SWIG_IsTmpObj(res2)) {
20862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20863 } else {
20864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20866 }
20867 if (SWIG_IsTmpObj(res3)) {
20868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20869 } else {
20870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20872 }
20873 return resultobj;
20874 fail:
20875 return NULL;
20876 }
20877
20878
20879 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20880 PyObject *resultobj = 0;
20881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20882 wxDC *arg2 = 0 ;
20883 wxPoint result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 void *argp2 = 0 ;
20887 int res2 = 0 ;
20888 PyObject * obj0 = 0 ;
20889 PyObject * obj1 = 0 ;
20890 char * kwnames[] = {
20891 (char *) "self",(char *) "dc", NULL
20892 };
20893
20894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20896 if (!SWIG_IsOK(res1)) {
20897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20898 }
20899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20901 if (!SWIG_IsOK(res2)) {
20902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20903 }
20904 if (!argp2) {
20905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20906 }
20907 arg2 = reinterpret_cast< wxDC * >(argp2);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20922 PyObject *resultobj = 0;
20923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20924 int result;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 PyObject *swig_obj[1] ;
20928
20929 if (!args) SWIG_fail;
20930 swig_obj[0] = args;
20931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20934 }
20935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (int)((wxMouseEvent const *)arg1)->GetX();
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_From_int(static_cast< int >(result));
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 int result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (int)((wxMouseEvent const *)arg1)->GetY();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 resultobj = SWIG_From_int(static_cast< int >(result));
20971 return resultobj;
20972 fail:
20973 return NULL;
20974 }
20975
20976
20977 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20978 PyObject *resultobj = 0;
20979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20980 int result;
20981 void *argp1 = 0 ;
20982 int res1 = 0 ;
20983 PyObject *swig_obj[1] ;
20984
20985 if (!args) SWIG_fail;
20986 swig_obj[0] = args;
20987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_From_int(static_cast< int >(result));
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21006 PyObject *resultobj = 0;
21007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21008 int result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 PyObject *swig_obj[1] ;
21012
21013 if (!args) SWIG_fail;
21014 swig_obj[0] = args;
21015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21018 }
21019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = SWIG_From_int(static_cast< int >(result));
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21036 int result;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 PyObject *swig_obj[1] ;
21040
21041 if (!args) SWIG_fail;
21042 swig_obj[0] = args;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21046 }
21047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = SWIG_From_int(static_cast< int >(result));
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 bool result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 {
21083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21084 }
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21092 PyObject *resultobj = 0;
21093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21094 int arg2 ;
21095 void *argp1 = 0 ;
21096 int res1 = 0 ;
21097 int val2 ;
21098 int ecode2 = 0 ;
21099 PyObject *swig_obj[2] ;
21100
21101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21105 }
21106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21108 if (!SWIG_IsOK(ecode2)) {
21109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21110 }
21111 arg2 = static_cast< int >(val2);
21112 if (arg1) (arg1)->m_x = arg2;
21113
21114 resultobj = SWIG_Py_Void();
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21122 PyObject *resultobj = 0;
21123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21124 int result;
21125 void *argp1 = 0 ;
21126 int res1 = 0 ;
21127 PyObject *swig_obj[1] ;
21128
21129 if (!args) SWIG_fail;
21130 swig_obj[0] = args;
21131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21134 }
21135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21136 result = (int) ((arg1)->m_x);
21137 resultobj = SWIG_From_int(static_cast< int >(result));
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21147 int arg2 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 int val2 ;
21151 int ecode2 = 0 ;
21152 PyObject *swig_obj[2] ;
21153
21154 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21161 if (!SWIG_IsOK(ecode2)) {
21162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21163 }
21164 arg2 = static_cast< int >(val2);
21165 if (arg1) (arg1)->m_y = arg2;
21166
21167 resultobj = SWIG_Py_Void();
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 result = (int) ((arg1)->m_y);
21190 resultobj = SWIG_From_int(static_cast< int >(result));
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21198 PyObject *resultobj = 0;
21199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21200 bool arg2 ;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 bool val2 ;
21204 int ecode2 = 0 ;
21205 PyObject *swig_obj[2] ;
21206
21207 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
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_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21214 if (!SWIG_IsOK(ecode2)) {
21215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21216 }
21217 arg2 = static_cast< bool >(val2);
21218 if (arg1) (arg1)->m_leftDown = arg2;
21219
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21240 }
21241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21242 result = (bool) ((arg1)->m_leftDown);
21243 {
21244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21245 }
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21253 PyObject *resultobj = 0;
21254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21255 bool arg2 ;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 bool val2 ;
21259 int ecode2 = 0 ;
21260 PyObject *swig_obj[2] ;
21261
21262 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21264 if (!SWIG_IsOK(res1)) {
21265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21266 }
21267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21268 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21269 if (!SWIG_IsOK(ecode2)) {
21270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21271 }
21272 arg2 = static_cast< bool >(val2);
21273 if (arg1) (arg1)->m_middleDown = arg2;
21274
21275 resultobj = SWIG_Py_Void();
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21283 PyObject *resultobj = 0;
21284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21285 bool result;
21286 void *argp1 = 0 ;
21287 int res1 = 0 ;
21288 PyObject *swig_obj[1] ;
21289
21290 if (!args) SWIG_fail;
21291 swig_obj[0] = args;
21292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21295 }
21296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21297 result = (bool) ((arg1)->m_middleDown);
21298 {
21299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21300 }
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 PyObject *resultobj = 0;
21309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21310 bool arg2 ;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 bool val2 ;
21314 int ecode2 = 0 ;
21315 PyObject *swig_obj[2] ;
21316
21317 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21321 }
21322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21323 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21324 if (!SWIG_IsOK(ecode2)) {
21325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21326 }
21327 arg2 = static_cast< bool >(val2);
21328 if (arg1) (arg1)->m_rightDown = arg2;
21329
21330 resultobj = SWIG_Py_Void();
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21338 PyObject *resultobj = 0;
21339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21340 bool result;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 PyObject *swig_obj[1] ;
21344
21345 if (!args) SWIG_fail;
21346 swig_obj[0] = args;
21347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21350 }
21351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21352 result = (bool) ((arg1)->m_rightDown);
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21365 bool arg2 ;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 bool val2 ;
21369 int ecode2 = 0 ;
21370 PyObject *swig_obj[2] ;
21371
21372 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21374 if (!SWIG_IsOK(res1)) {
21375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21376 }
21377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21378 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21379 if (!SWIG_IsOK(ecode2)) {
21380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21381 }
21382 arg2 = static_cast< bool >(val2);
21383 if (arg1) (arg1)->m_controlDown = arg2;
21384
21385 resultobj = SWIG_Py_Void();
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool result;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 PyObject *swig_obj[1] ;
21399
21400 if (!args) SWIG_fail;
21401 swig_obj[0] = args;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 result = (bool) ((arg1)->m_controlDown);
21408 {
21409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21418 PyObject *resultobj = 0;
21419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21420 bool arg2 ;
21421 void *argp1 = 0 ;
21422 int res1 = 0 ;
21423 bool val2 ;
21424 int ecode2 = 0 ;
21425 PyObject *swig_obj[2] ;
21426
21427 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21429 if (!SWIG_IsOK(res1)) {
21430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21431 }
21432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21433 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21434 if (!SWIG_IsOK(ecode2)) {
21435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21436 }
21437 arg2 = static_cast< bool >(val2);
21438 if (arg1) (arg1)->m_shiftDown = arg2;
21439
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21460 }
21461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21462 result = (bool) ((arg1)->m_shiftDown);
21463 {
21464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21465 }
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21473 PyObject *resultobj = 0;
21474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21475 bool arg2 ;
21476 void *argp1 = 0 ;
21477 int res1 = 0 ;
21478 bool val2 ;
21479 int ecode2 = 0 ;
21480 PyObject *swig_obj[2] ;
21481
21482 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21484 if (!SWIG_IsOK(res1)) {
21485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21486 }
21487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21488 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21489 if (!SWIG_IsOK(ecode2)) {
21490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21491 }
21492 arg2 = static_cast< bool >(val2);
21493 if (arg1) (arg1)->m_altDown = arg2;
21494
21495 resultobj = SWIG_Py_Void();
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21505 bool result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 PyObject *swig_obj[1] ;
21509
21510 if (!args) SWIG_fail;
21511 swig_obj[0] = args;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21515 }
21516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21517 result = (bool) ((arg1)->m_altDown);
21518 {
21519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21528 PyObject *resultobj = 0;
21529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21530 bool arg2 ;
21531 void *argp1 = 0 ;
21532 int res1 = 0 ;
21533 bool val2 ;
21534 int ecode2 = 0 ;
21535 PyObject *swig_obj[2] ;
21536
21537 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
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_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21544 if (!SWIG_IsOK(ecode2)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21546 }
21547 arg2 = static_cast< bool >(val2);
21548 if (arg1) (arg1)->m_metaDown = arg2;
21549
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 result = (bool) ((arg1)->m_metaDown);
21573 {
21574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21575 }
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21583 PyObject *resultobj = 0;
21584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21585 int arg2 ;
21586 void *argp1 = 0 ;
21587 int res1 = 0 ;
21588 int val2 ;
21589 int ecode2 = 0 ;
21590 PyObject *swig_obj[2] ;
21591
21592 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21594 if (!SWIG_IsOK(res1)) {
21595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21596 }
21597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21598 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21599 if (!SWIG_IsOK(ecode2)) {
21600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21601 }
21602 arg2 = static_cast< int >(val2);
21603 if (arg1) (arg1)->m_wheelRotation = arg2;
21604
21605 resultobj = SWIG_Py_Void();
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *resultobj = 0;
21614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21615 int result;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 PyObject *swig_obj[1] ;
21619
21620 if (!args) SWIG_fail;
21621 swig_obj[0] = args;
21622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21625 }
21626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21627 result = (int) ((arg1)->m_wheelRotation);
21628 resultobj = SWIG_From_int(static_cast< int >(result));
21629 return resultobj;
21630 fail:
21631 return NULL;
21632 }
21633
21634
21635 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21636 PyObject *resultobj = 0;
21637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21638 int arg2 ;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 int val2 ;
21642 int ecode2 = 0 ;
21643 PyObject *swig_obj[2] ;
21644
21645 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21647 if (!SWIG_IsOK(res1)) {
21648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21649 }
21650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21652 if (!SWIG_IsOK(ecode2)) {
21653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21654 }
21655 arg2 = static_cast< int >(val2);
21656 if (arg1) (arg1)->m_wheelDelta = arg2;
21657
21658 resultobj = SWIG_Py_Void();
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21668 int result;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21678 }
21679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21680 result = (int) ((arg1)->m_wheelDelta);
21681 resultobj = SWIG_From_int(static_cast< int >(result));
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21691 int arg2 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 int val2 ;
21695 int ecode2 = 0 ;
21696 PyObject *swig_obj[2] ;
21697
21698 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21705 if (!SWIG_IsOK(ecode2)) {
21706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21707 }
21708 arg2 = static_cast< int >(val2);
21709 if (arg1) (arg1)->m_linesPerAction = arg2;
21710
21711 resultobj = SWIG_Py_Void();
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719 PyObject *resultobj = 0;
21720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21721 int result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 PyObject *swig_obj[1] ;
21725
21726 if (!args) SWIG_fail;
21727 swig_obj[0] = args;
21728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21731 }
21732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21733 result = (int) ((arg1)->m_linesPerAction);
21734 resultobj = SWIG_From_int(static_cast< int >(result));
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 int arg1 = (int) 0 ;
21755 int arg2 = (int) 0 ;
21756 wxSetCursorEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "x",(char *) "y", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21772 }
21773 arg1 = static_cast< int >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21824 PyObject *resultobj = 0;
21825 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21826 int result;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 PyObject *swig_obj[1] ;
21830
21831 if (!args) SWIG_fail;
21832 swig_obj[0] = args;
21833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21834 if (!SWIG_IsOK(res1)) {
21835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21836 }
21837 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 resultobj = SWIG_From_int(static_cast< int >(result));
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = 0;
21853 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21854 wxCursor *arg2 = 0 ;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 void *argp2 = 0 ;
21858 int res2 = 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "self",(char *) "cursor", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21867 if (!SWIG_IsOK(res1)) {
21868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21869 }
21870 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21871 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21872 if (!SWIG_IsOK(res2)) {
21873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21874 }
21875 if (!argp2) {
21876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21877 }
21878 arg2 = reinterpret_cast< wxCursor * >(argp2);
21879 {
21880 PyThreadState* __tstate = wxPyBeginAllowThreads();
21881 (arg1)->SetCursor((wxCursor const &)*arg2);
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 resultobj = SWIG_Py_Void();
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21893 PyObject *resultobj = 0;
21894 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21895 wxCursor *result = 0 ;
21896 void *argp1 = 0 ;
21897 int res1 = 0 ;
21898 PyObject *swig_obj[1] ;
21899
21900 if (!args) SWIG_fail;
21901 swig_obj[0] = args;
21902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21903 if (!SWIG_IsOK(res1)) {
21904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21905 }
21906 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 {
21910 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21911 result = (wxCursor *) &_result_ref;
21912 }
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 wxCursor* resultptr = new wxCursor(*result);
21918 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21927 PyObject *resultobj = 0;
21928 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21929 bool result;
21930 void *argp1 = 0 ;
21931 int res1 = 0 ;
21932 PyObject *swig_obj[1] ;
21933
21934 if (!args) SWIG_fail;
21935 swig_obj[0] = args;
21936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21939 }
21940 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21941 {
21942 PyThreadState* __tstate = wxPyBeginAllowThreads();
21943 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 {
21948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21949 }
21950 return resultobj;
21951 fail:
21952 return NULL;
21953 }
21954
21955
21956 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21957 PyObject *obj;
21958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21959 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21960 return SWIG_Py_Void();
21961 }
21962
21963 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21964 return SWIG_Python_InitShadowInstance(args);
21965 }
21966
21967 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = 0;
21969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21970 wxKeyEvent *result = 0 ;
21971 int val1 ;
21972 int ecode1 = 0 ;
21973 PyObject * obj0 = 0 ;
21974 char * kwnames[] = {
21975 (char *) "eventType", NULL
21976 };
21977
21978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21979 if (obj0) {
21980 ecode1 = SWIG_AsVal_int(obj0, &val1);
21981 if (!SWIG_IsOK(ecode1)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21983 }
21984 arg1 = static_cast< wxEventType >(val1);
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22002 int result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_From_int(static_cast< int >(result));
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22028 PyObject *resultobj = 0;
22029 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22030 bool result;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 PyObject *swig_obj[1] ;
22034
22035 if (!args) SWIG_fail;
22036 swig_obj[0] = args;
22037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22040 }
22041 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 {
22049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22050 }
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 PyObject *resultobj = 0;
22059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22060 bool result;
22061 void *argp1 = 0 ;
22062 int res1 = 0 ;
22063 PyObject *swig_obj[1] ;
22064
22065 if (!args) SWIG_fail;
22066 swig_obj[0] = args;
22067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22068 if (!SWIG_IsOK(res1)) {
22069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22070 }
22071 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 PyObject *resultobj = 0;
22089 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22090 bool result;
22091 void *argp1 = 0 ;
22092 int res1 = 0 ;
22093 PyObject *swig_obj[1] ;
22094
22095 if (!args) SWIG_fail;
22096 swig_obj[0] = args;
22097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22098 if (!SWIG_IsOK(res1)) {
22099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22100 }
22101 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22120 bool result;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 PyObject *swig_obj[1] ;
22124
22125 if (!args) SWIG_fail;
22126 swig_obj[0] = args;
22127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22130 }
22131 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 {
22139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22140 }
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22148 PyObject *resultobj = 0;
22149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22150 bool result;
22151 void *argp1 = 0 ;
22152 int res1 = 0 ;
22153 PyObject *swig_obj[1] ;
22154
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22178 PyObject *resultobj = 0;
22179 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22180 bool result;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject *swig_obj[1] ;
22184
22185 if (!args) SWIG_fail;
22186 swig_obj[0] = args;
22187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22188 if (!SWIG_IsOK(res1)) {
22189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22190 }
22191 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22210 int result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22220 }
22221 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_From_int(static_cast< int >(result));
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22238 int result;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_From_int(static_cast< int >(result));
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22266 int arg2 ;
22267 void *argp1 = 0 ;
22268 int res1 = 0 ;
22269 int val2 ;
22270 int ecode2 = 0 ;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char * kwnames[] = {
22274 (char *) "self",(char *) "uniChar", NULL
22275 };
22276
22277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22281 }
22282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22283 ecode2 = SWIG_AsVal_int(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22286 }
22287 arg2 = static_cast< int >(val2);
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 resultobj = SWIG_Py_Void();
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 PyObject *resultobj = 0;
22303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22304 unsigned int result;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22314 }
22315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 unsigned int result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22358 PyObject *resultobj = 0;
22359 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22360 wxPoint result;
22361 void *argp1 = 0 ;
22362 int res1 = 0 ;
22363 PyObject *swig_obj[1] ;
22364
22365 if (!args) SWIG_fail;
22366 swig_obj[0] = args;
22367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22368 if (!SWIG_IsOK(res1)) {
22369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22370 }
22371 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (arg1)->GetPosition();
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22386 PyObject *resultobj = 0;
22387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22388 long *arg2 = (long *) 0 ;
22389 long *arg3 = (long *) 0 ;
22390 void *argp1 = 0 ;
22391 int res1 = 0 ;
22392 long temp2 ;
22393 int res2 = SWIG_TMPOBJ ;
22394 long temp3 ;
22395 int res3 = SWIG_TMPOBJ ;
22396 PyObject *swig_obj[1] ;
22397
22398 arg2 = &temp2;
22399 arg3 = &temp3;
22400 if (!args) SWIG_fail;
22401 swig_obj[0] = args;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 (arg1)->GetPosition(arg2,arg3);
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = SWIG_Py_Void();
22414 if (SWIG_IsTmpObj(res2)) {
22415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22416 } else {
22417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22419 }
22420 if (SWIG_IsTmpObj(res3)) {
22421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22422 } else {
22423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)((wxKeyEvent const *)arg1)->GetX();
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = (int)((wxKeyEvent const *)arg1)->GetY();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_From_int(static_cast< int >(result));
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22491 int arg2 ;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 int val2 ;
22495 int ecode2 = 0 ;
22496 PyObject *swig_obj[2] ;
22497
22498 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22505 if (!SWIG_IsOK(ecode2)) {
22506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22507 }
22508 arg2 = static_cast< int >(val2);
22509 if (arg1) (arg1)->m_x = arg2;
22510
22511 resultobj = SWIG_Py_Void();
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22519 PyObject *resultobj = 0;
22520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22521 int result;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 PyObject *swig_obj[1] ;
22525
22526 if (!args) SWIG_fail;
22527 swig_obj[0] = args;
22528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22531 }
22532 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22533 result = (int) ((arg1)->m_x);
22534 resultobj = SWIG_From_int(static_cast< int >(result));
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22542 PyObject *resultobj = 0;
22543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22544 int arg2 ;
22545 void *argp1 = 0 ;
22546 int res1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 PyObject *swig_obj[2] ;
22550
22551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22555 }
22556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22557 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22558 if (!SWIG_IsOK(ecode2)) {
22559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22560 }
22561 arg2 = static_cast< int >(val2);
22562 if (arg1) (arg1)->m_y = arg2;
22563
22564 resultobj = SWIG_Py_Void();
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22572 PyObject *resultobj = 0;
22573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22574 int result;
22575 void *argp1 = 0 ;
22576 int res1 = 0 ;
22577 PyObject *swig_obj[1] ;
22578
22579 if (!args) SWIG_fail;
22580 swig_obj[0] = args;
22581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22584 }
22585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22586 result = (int) ((arg1)->m_y);
22587 resultobj = SWIG_From_int(static_cast< int >(result));
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22597 long arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 long val2 ;
22601 int ecode2 = 0 ;
22602 PyObject *swig_obj[2] ;
22603
22604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22613 }
22614 arg2 = static_cast< long >(val2);
22615 if (arg1) (arg1)->m_keyCode = arg2;
22616
22617 resultobj = SWIG_Py_Void();
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 long result;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 PyObject *swig_obj[1] ;
22631
22632 if (!args) SWIG_fail;
22633 swig_obj[0] = args;
22634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22639 result = (long) ((arg1)->m_keyCode);
22640 resultobj = SWIG_From_long(static_cast< long >(result));
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22650 bool arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 bool val2 ;
22654 int ecode2 = 0 ;
22655 PyObject *swig_obj[2] ;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22661 }
22662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22663 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22666 }
22667 arg2 = static_cast< bool >(val2);
22668 if (arg1) (arg1)->m_controlDown = arg2;
22669
22670 resultobj = SWIG_Py_Void();
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 bool result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22692 result = (bool) ((arg1)->m_controlDown);
22693 {
22694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22695 }
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22705 bool arg2 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 bool val2 ;
22709 int ecode2 = 0 ;
22710 PyObject *swig_obj[2] ;
22711
22712 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22716 }
22717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22718 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22719 if (!SWIG_IsOK(ecode2)) {
22720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22721 }
22722 arg2 = static_cast< bool >(val2);
22723 if (arg1) (arg1)->m_shiftDown = arg2;
22724
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 bool result;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 PyObject *swig_obj[1] ;
22739
22740 if (!args) SWIG_fail;
22741 swig_obj[0] = args;
22742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22745 }
22746 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22747 result = (bool) ((arg1)->m_shiftDown);
22748 {
22749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22758 PyObject *resultobj = 0;
22759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22760 bool arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 bool val2 ;
22764 int ecode2 = 0 ;
22765 PyObject *swig_obj[2] ;
22766
22767 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22771 }
22772 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22773 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22774 if (!SWIG_IsOK(ecode2)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22776 }
22777 arg2 = static_cast< bool >(val2);
22778 if (arg1) (arg1)->m_altDown = arg2;
22779
22780 resultobj = SWIG_Py_Void();
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 PyObject *resultobj = 0;
22789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22790 bool result;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 PyObject *swig_obj[1] ;
22794
22795 if (!args) SWIG_fail;
22796 swig_obj[0] = args;
22797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22798 if (!SWIG_IsOK(res1)) {
22799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22800 }
22801 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22802 result = (bool) ((arg1)->m_altDown);
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22813 PyObject *resultobj = 0;
22814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22815 bool arg2 ;
22816 void *argp1 = 0 ;
22817 int res1 = 0 ;
22818 bool val2 ;
22819 int ecode2 = 0 ;
22820 PyObject *swig_obj[2] ;
22821
22822 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22824 if (!SWIG_IsOK(res1)) {
22825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22826 }
22827 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22828 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22829 if (!SWIG_IsOK(ecode2)) {
22830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22831 }
22832 arg2 = static_cast< bool >(val2);
22833 if (arg1) (arg1)->m_metaDown = arg2;
22834
22835 resultobj = SWIG_Py_Void();
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22843 PyObject *resultobj = 0;
22844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 PyObject *swig_obj[1] ;
22849
22850 if (!args) SWIG_fail;
22851 swig_obj[0] = args;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22857 result = (bool) ((arg1)->m_metaDown);
22858 {
22859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22860 }
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22870 bool arg2 ;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 bool val2 ;
22874 int ecode2 = 0 ;
22875 PyObject *swig_obj[2] ;
22876
22877 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22881 }
22882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22883 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22884 if (!SWIG_IsOK(ecode2)) {
22885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22886 }
22887 arg2 = static_cast< bool >(val2);
22888 if (arg1) (arg1)->m_scanCode = arg2;
22889
22890 resultobj = SWIG_Py_Void();
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 result = (bool) ((arg1)->m_scanCode);
22913 {
22914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22915 }
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22925 unsigned int arg2 ;
22926 void *argp1 = 0 ;
22927 int res1 = 0 ;
22928 unsigned int val2 ;
22929 int ecode2 = 0 ;
22930 PyObject *swig_obj[2] ;
22931
22932 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22934 if (!SWIG_IsOK(res1)) {
22935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22936 }
22937 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22938 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22939 if (!SWIG_IsOK(ecode2)) {
22940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22941 }
22942 arg2 = static_cast< unsigned int >(val2);
22943 if (arg1) (arg1)->m_rawCode = arg2;
22944
22945 resultobj = SWIG_Py_Void();
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22953 PyObject *resultobj = 0;
22954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22955 unsigned int result;
22956 void *argp1 = 0 ;
22957 int res1 = 0 ;
22958 PyObject *swig_obj[1] ;
22959
22960 if (!args) SWIG_fail;
22961 swig_obj[0] = args;
22962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22963 if (!SWIG_IsOK(res1)) {
22964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22965 }
22966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22967 result = (unsigned int) ((arg1)->m_rawCode);
22968 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 PyObject *resultobj = 0;
22977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22978 unsigned int arg2 ;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 unsigned int val2 ;
22982 int ecode2 = 0 ;
22983 PyObject *swig_obj[2] ;
22984
22985 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22987 if (!SWIG_IsOK(res1)) {
22988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22989 }
22990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22991 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22992 if (!SWIG_IsOK(ecode2)) {
22993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22994 }
22995 arg2 = static_cast< unsigned int >(val2);
22996 if (arg1) (arg1)->m_rawFlags = arg2;
22997
22998 resultobj = SWIG_Py_Void();
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23006 PyObject *resultobj = 0;
23007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23008 unsigned int result;
23009 void *argp1 = 0 ;
23010 int res1 = 0 ;
23011 PyObject *swig_obj[1] ;
23012
23013 if (!args) SWIG_fail;
23014 swig_obj[0] = args;
23015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23016 if (!SWIG_IsOK(res1)) {
23017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23018 }
23019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23020 result = (unsigned int) ((arg1)->m_rawFlags);
23021 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23029 PyObject *obj;
23030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23031 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23032 return SWIG_Py_Void();
23033 }
23034
23035 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23036 return SWIG_Python_InitShadowInstance(args);
23037 }
23038
23039 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj = 0;
23041 wxSize const &arg1_defvalue = wxDefaultSize ;
23042 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23043 int arg2 = (int) 0 ;
23044 wxSizeEvent *result = 0 ;
23045 wxSize temp1 ;
23046 int val2 ;
23047 int ecode2 = 0 ;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "sz",(char *) "winid", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23055 if (obj0) {
23056 {
23057 arg1 = &temp1;
23058 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23059 }
23060 }
23061 if (obj1) {
23062 ecode2 = SWIG_AsVal_int(obj1, &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23065 }
23066 arg2 = static_cast< int >(val2);
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23084 wxSize result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = ((wxSizeEvent const *)arg1)->GetSize();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23112 wxRect result;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = ((wxSizeEvent const *)arg1)->GetRect();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj = 0;
23139 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23140 wxRect arg2 ;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 void *argp2 ;
23144 int res2 = 0 ;
23145 PyObject * obj0 = 0 ;
23146 PyObject * obj1 = 0 ;
23147 char * kwnames[] = {
23148 (char *) "self",(char *) "rect", NULL
23149 };
23150
23151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23153 if (!SWIG_IsOK(res1)) {
23154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23155 }
23156 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23157 {
23158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23159 if (!SWIG_IsOK(res2)) {
23160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23161 }
23162 if (!argp2) {
23163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23164 } else {
23165 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23166 arg2 = *temp;
23167 if (SWIG_IsNewObj(res2)) delete temp;
23168 }
23169 }
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 (arg1)->SetRect(arg2);
23173 wxPyEndAllowThreads(__tstate);
23174 if (PyErr_Occurred()) SWIG_fail;
23175 }
23176 resultobj = SWIG_Py_Void();
23177 return resultobj;
23178 fail:
23179 return NULL;
23180 }
23181
23182
23183 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23184 PyObject *resultobj = 0;
23185 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23186 wxSize arg2 ;
23187 void *argp1 = 0 ;
23188 int res1 = 0 ;
23189 void *argp2 ;
23190 int res2 = 0 ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "size", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23201 }
23202 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23203 {
23204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23205 if (!SWIG_IsOK(res2)) {
23206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23207 }
23208 if (!argp2) {
23209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23210 } else {
23211 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23212 arg2 = *temp;
23213 if (SWIG_IsNewObj(res2)) delete temp;
23214 }
23215 }
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 wxSizeEvent_SetSize(arg1,arg2);
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_Py_Void();
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23232 wxSize *arg2 = (wxSize *) 0 ;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 void *argp2 = 0 ;
23236 int res2 = 0 ;
23237 PyObject *swig_obj[2] ;
23238
23239 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23241 if (!SWIG_IsOK(res1)) {
23242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23243 }
23244 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23246 if (!SWIG_IsOK(res2)) {
23247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23248 }
23249 arg2 = reinterpret_cast< wxSize * >(argp2);
23250 if (arg1) (arg1)->m_size = *arg2;
23251
23252 resultobj = SWIG_Py_Void();
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23260 PyObject *resultobj = 0;
23261 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23262 wxSize *result = 0 ;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 PyObject *swig_obj[1] ;
23266
23267 if (!args) SWIG_fail;
23268 swig_obj[0] = args;
23269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23272 }
23273 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23274 result = (wxSize *)& ((arg1)->m_size);
23275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23283 PyObject *resultobj = 0;
23284 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23285 wxRect *arg2 = (wxRect *) 0 ;
23286 void *argp1 = 0 ;
23287 int res1 = 0 ;
23288 void *argp2 = 0 ;
23289 int res2 = 0 ;
23290 PyObject *swig_obj[2] ;
23291
23292 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23294 if (!SWIG_IsOK(res1)) {
23295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23296 }
23297 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23299 if (!SWIG_IsOK(res2)) {
23300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23301 }
23302 arg2 = reinterpret_cast< wxRect * >(argp2);
23303 if (arg1) (arg1)->m_rect = *arg2;
23304
23305 resultobj = SWIG_Py_Void();
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23313 PyObject *resultobj = 0;
23314 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23315 wxRect *result = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 PyObject *swig_obj[1] ;
23319
23320 if (!args) SWIG_fail;
23321 swig_obj[0] = args;
23322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23323 if (!SWIG_IsOK(res1)) {
23324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23325 }
23326 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23327 result = (wxRect *)& ((arg1)->m_rect);
23328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *obj;
23337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23338 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23339 return SWIG_Py_Void();
23340 }
23341
23342 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 return SWIG_Python_InitShadowInstance(args);
23344 }
23345
23346 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj = 0;
23348 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23349 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23350 int arg2 = (int) 0 ;
23351 wxMoveEvent *result = 0 ;
23352 wxPoint temp1 ;
23353 int val2 ;
23354 int ecode2 = 0 ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char * kwnames[] = {
23358 (char *) "pos",(char *) "winid", NULL
23359 };
23360
23361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23362 if (obj0) {
23363 {
23364 arg1 = &temp1;
23365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23366 }
23367 }
23368 if (obj1) {
23369 ecode2 = SWIG_AsVal_int(obj1, &val2);
23370 if (!SWIG_IsOK(ecode2)) {
23371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23372 }
23373 arg2 = static_cast< int >(val2);
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23391 wxPoint result;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 PyObject *swig_obj[1] ;
23395
23396 if (!args) SWIG_fail;
23397 swig_obj[0] = args;
23398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23401 }
23402 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = ((wxMoveEvent const *)arg1)->GetPosition();
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 PyObject *resultobj = 0;
23418 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23419 wxRect result;
23420 void *argp1 = 0 ;
23421 int res1 = 0 ;
23422 PyObject *swig_obj[1] ;
23423
23424 if (!args) SWIG_fail;
23425 swig_obj[0] = args;
23426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23427 if (!SWIG_IsOK(res1)) {
23428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23429 }
23430 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = ((wxMoveEvent const *)arg1)->GetRect();
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj = 0;
23446 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23447 wxRect *arg2 = 0 ;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 wxRect temp2 ;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 char * kwnames[] = {
23454 (char *) "self",(char *) "rect", NULL
23455 };
23456
23457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23459 if (!SWIG_IsOK(res1)) {
23460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23461 }
23462 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23463 {
23464 arg2 = &temp2;
23465 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 (arg1)->SetRect((wxRect const &)*arg2);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_Py_Void();
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23483 wxPoint *arg2 = 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 wxPoint temp2 ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "self",(char *) "pos", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23495 if (!SWIG_IsOK(res1)) {
23496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23497 }
23498 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23499 {
23500 arg2 = &temp2;
23501 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 (arg1)->SetPosition((wxPoint const &)*arg2);
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 resultobj = SWIG_Py_Void();
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *obj;
23518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23519 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23520 return SWIG_Py_Void();
23521 }
23522
23523 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 return SWIG_Python_InitShadowInstance(args);
23525 }
23526
23527 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 int arg1 = (int) 0 ;
23530 wxPaintEvent *result = 0 ;
23531 int val1 ;
23532 int ecode1 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 char * kwnames[] = {
23535 (char *) "Id", NULL
23536 };
23537
23538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23539 if (obj0) {
23540 ecode1 = SWIG_AsVal_int(obj0, &val1);
23541 if (!SWIG_IsOK(ecode1)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23543 }
23544 arg1 = static_cast< int >(val1);
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23560 PyObject *obj;
23561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23563 return SWIG_Py_Void();
23564 }
23565
23566 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23567 return SWIG_Python_InitShadowInstance(args);
23568 }
23569
23570 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj = 0;
23572 int arg1 = (int) 0 ;
23573 wxNcPaintEvent *result = 0 ;
23574 int val1 ;
23575 int ecode1 = 0 ;
23576 PyObject * obj0 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "winid", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23582 if (obj0) {
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23586 }
23587 arg1 = static_cast< int >(val1);
23588 }
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 PyObject *obj;
23604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23605 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23606 return SWIG_Py_Void();
23607 }
23608
23609 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 return SWIG_Python_InitShadowInstance(args);
23611 }
23612
23613 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj = 0;
23615 int arg1 = (int) 0 ;
23616 wxDC *arg2 = (wxDC *) NULL ;
23617 wxEraseEvent *result = 0 ;
23618 int val1 ;
23619 int ecode1 = 0 ;
23620 void *argp2 = 0 ;
23621 int res2 = 0 ;
23622 PyObject * obj0 = 0 ;
23623 PyObject * obj1 = 0 ;
23624 char * kwnames[] = {
23625 (char *) "Id",(char *) "dc", NULL
23626 };
23627
23628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23629 if (obj0) {
23630 ecode1 = SWIG_AsVal_int(obj0, &val1);
23631 if (!SWIG_IsOK(ecode1)) {
23632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23633 }
23634 arg1 = static_cast< int >(val1);
23635 }
23636 if (obj1) {
23637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23638 if (!SWIG_IsOK(res2)) {
23639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23640 }
23641 arg2 = reinterpret_cast< wxDC * >(argp2);
23642 }
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23646 wxPyEndAllowThreads(__tstate);
23647 if (PyErr_Occurred()) SWIG_fail;
23648 }
23649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23650 return resultobj;
23651 fail:
23652 return NULL;
23653 }
23654
23655
23656 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23657 PyObject *resultobj = 0;
23658 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23659 wxDC *result = 0 ;
23660 void *argp1 = 0 ;
23661 int res1 = 0 ;
23662 PyObject *swig_obj[1] ;
23663
23664 if (!args) SWIG_fail;
23665 swig_obj[0] = args;
23666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23667 if (!SWIG_IsOK(res1)) {
23668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23669 }
23670 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = wxPyMake_wxObject(result, (bool)0);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *obj;
23688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23689 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23690 return SWIG_Py_Void();
23691 }
23692
23693 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694 return SWIG_Python_InitShadowInstance(args);
23695 }
23696
23697 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj = 0;
23699 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23700 int arg2 = (int) 0 ;
23701 wxFocusEvent *result = 0 ;
23702 int val1 ;
23703 int ecode1 = 0 ;
23704 int val2 ;
23705 int ecode2 = 0 ;
23706 PyObject * obj0 = 0 ;
23707 PyObject * obj1 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "type",(char *) "winid", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23713 if (obj0) {
23714 ecode1 = SWIG_AsVal_int(obj0, &val1);
23715 if (!SWIG_IsOK(ecode1)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23717 }
23718 arg1 = static_cast< wxEventType >(val1);
23719 }
23720 if (obj1) {
23721 ecode2 = SWIG_AsVal_int(obj1, &val2);
23722 if (!SWIG_IsOK(ecode2)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23724 }
23725 arg2 = static_cast< int >(val2);
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 PyObject *resultobj = 0;
23742 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23743 wxWindow *result = 0 ;
23744 void *argp1 = 0 ;
23745 int res1 = 0 ;
23746 PyObject *swig_obj[1] ;
23747
23748 if (!args) SWIG_fail;
23749 swig_obj[0] = args;
23750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23753 }
23754 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 {
23762 resultobj = wxPyMake_wxObject(result, (bool)0);
23763 }
23764 return resultobj;
23765 fail:
23766 return NULL;
23767 }
23768
23769
23770 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23773 wxWindow *arg2 = (wxWindow *) 0 ;
23774 void *argp1 = 0 ;
23775 int res1 = 0 ;
23776 void *argp2 = 0 ;
23777 int res2 = 0 ;
23778 PyObject * obj0 = 0 ;
23779 PyObject * obj1 = 0 ;
23780 char * kwnames[] = {
23781 (char *) "self",(char *) "win", NULL
23782 };
23783
23784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23786 if (!SWIG_IsOK(res1)) {
23787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23788 }
23789 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23791 if (!SWIG_IsOK(res2)) {
23792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23793 }
23794 arg2 = reinterpret_cast< wxWindow * >(argp2);
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 (arg1)->SetWindow(arg2);
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_Py_Void();
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxWindow *arg1 = (wxWindow *) NULL ;
23822 wxChildFocusEvent *result = 0 ;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "win", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23831 if (obj0) {
23832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23833 if (!SWIG_IsOK(res1)) {
23834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23835 }
23836 arg1 = reinterpret_cast< wxWindow * >(argp1);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *resultobj = 0;
23853 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23854 wxWindow *result = 0 ;
23855 void *argp1 = 0 ;
23856 int res1 = 0 ;
23857 PyObject *swig_obj[1] ;
23858
23859 if (!args) SWIG_fail;
23860 swig_obj[0] = args;
23861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23862 if (!SWIG_IsOK(res1)) {
23863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23864 }
23865 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 resultobj = wxPyMake_wxObject(result, (bool)0);
23874 }
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23882 PyObject *obj;
23883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23884 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23885 return SWIG_Py_Void();
23886 }
23887
23888 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 return SWIG_Python_InitShadowInstance(args);
23890 }
23891
23892 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23895 bool arg2 = (bool) true ;
23896 int arg3 = (int) 0 ;
23897 wxActivateEvent *result = 0 ;
23898 int val1 ;
23899 int ecode1 = 0 ;
23900 bool val2 ;
23901 int ecode2 = 0 ;
23902 int val3 ;
23903 int ecode3 = 0 ;
23904 PyObject * obj0 = 0 ;
23905 PyObject * obj1 = 0 ;
23906 PyObject * obj2 = 0 ;
23907 char * kwnames[] = {
23908 (char *) "type",(char *) "active",(char *) "Id", NULL
23909 };
23910
23911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23912 if (obj0) {
23913 ecode1 = SWIG_AsVal_int(obj0, &val1);
23914 if (!SWIG_IsOK(ecode1)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23916 }
23917 arg1 = static_cast< wxEventType >(val1);
23918 }
23919 if (obj1) {
23920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23921 if (!SWIG_IsOK(ecode2)) {
23922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23923 }
23924 arg2 = static_cast< bool >(val2);
23925 }
23926 if (obj2) {
23927 ecode3 = SWIG_AsVal_int(obj2, &val3);
23928 if (!SWIG_IsOK(ecode3)) {
23929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23930 }
23931 arg3 = static_cast< int >(val3);
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23947 PyObject *resultobj = 0;
23948 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23949 bool result;
23950 void *argp1 = 0 ;
23951 int res1 = 0 ;
23952 PyObject *swig_obj[1] ;
23953
23954 if (!args) SWIG_fail;
23955 swig_obj[0] = args;
23956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23959 }
23960 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 {
23968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *obj;
23978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23979 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23980 return SWIG_Py_Void();
23981 }
23982
23983 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 return SWIG_Python_InitShadowInstance(args);
23985 }
23986
23987 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23988 PyObject *resultobj = 0;
23989 int arg1 = (int) 0 ;
23990 wxInitDialogEvent *result = 0 ;
23991 int val1 ;
23992 int ecode1 = 0 ;
23993 PyObject * obj0 = 0 ;
23994 char * kwnames[] = {
23995 (char *) "Id", NULL
23996 };
23997
23998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23999 if (obj0) {
24000 ecode1 = SWIG_AsVal_int(obj0, &val1);
24001 if (!SWIG_IsOK(ecode1)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24003 }
24004 arg1 = static_cast< int >(val1);
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *obj;
24021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24022 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24023 return SWIG_Py_Void();
24024 }
24025
24026 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 return SWIG_Python_InitShadowInstance(args);
24028 }
24029
24030 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj = 0;
24032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24033 int arg2 = (int) 0 ;
24034 wxMenu *arg3 = (wxMenu *) NULL ;
24035 wxMenuEvent *result = 0 ;
24036 int val1 ;
24037 int ecode1 = 0 ;
24038 int val2 ;
24039 int ecode2 = 0 ;
24040 void *argp3 = 0 ;
24041 int res3 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 PyObject * obj2 = 0 ;
24045 char * kwnames[] = {
24046 (char *) "type",(char *) "winid",(char *) "menu", NULL
24047 };
24048
24049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24050 if (obj0) {
24051 ecode1 = SWIG_AsVal_int(obj0, &val1);
24052 if (!SWIG_IsOK(ecode1)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24054 }
24055 arg1 = static_cast< wxEventType >(val1);
24056 }
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24061 }
24062 arg2 = static_cast< int >(val2);
24063 }
24064 if (obj2) {
24065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24066 if (!SWIG_IsOK(res3)) {
24067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24068 }
24069 arg3 = reinterpret_cast< wxMenu * >(argp3);
24070 }
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24085 PyObject *resultobj = 0;
24086 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24087 int result;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24097 }
24098 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_From_int(static_cast< int >(result));
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24113 PyObject *resultobj = 0;
24114 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24115 bool result;
24116 void *argp1 = 0 ;
24117 int res1 = 0 ;
24118 PyObject *swig_obj[1] ;
24119
24120 if (!args) SWIG_fail;
24121 swig_obj[0] = args;
24122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24123 if (!SWIG_IsOK(res1)) {
24124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24125 }
24126 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24145 wxMenu *result = 0 ;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = wxPyMake_wxObject(result, (bool)0);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24186 int arg2 = (int) 0 ;
24187 wxCloseEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 int val2 ;
24191 int ecode2 = 0 ;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "type",(char *) "winid", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24199 if (obj0) {
24200 ecode1 = SWIG_AsVal_int(obj0, &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24203 }
24204 arg1 = static_cast< wxEventType >(val1);
24205 }
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_int(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24210 }
24211 arg2 = static_cast< int >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24229 bool arg2 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 bool val2 ;
24233 int ecode2 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "logOff", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24249 }
24250 arg2 = static_cast< bool >(val2);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetLoggingOff(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_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24267 bool result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj = 0;
24296 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24297 bool arg2 = (bool) true ;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 bool val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "self",(char *) "veto", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24314 if (obj1) {
24315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24316 if (!SWIG_IsOK(ecode2)) {
24317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24318 }
24319 arg2 = static_cast< bool >(val2);
24320 }
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 (arg1)->Veto(arg2);
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 resultobj = SWIG_Py_Void();
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 PyObject *resultobj = 0;
24336 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24337 bool result;
24338 void *argp1 = 0 ;
24339 int res1 = 0 ;
24340 PyObject *swig_obj[1] ;
24341
24342 if (!args) SWIG_fail;
24343 swig_obj[0] = args;
24344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24345 if (!SWIG_IsOK(res1)) {
24346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24347 }
24348 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24349 {
24350 PyThreadState* __tstate = wxPyBeginAllowThreads();
24351 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 {
24356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24357 }
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj = 0;
24366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24367 bool arg2 ;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 bool val2 ;
24371 int ecode2 = 0 ;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 char * kwnames[] = {
24375 (char *) "self",(char *) "canVeto", NULL
24376 };
24377
24378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24380 if (!SWIG_IsOK(res1)) {
24381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24382 }
24383 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24385 if (!SWIG_IsOK(ecode2)) {
24386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24387 }
24388 arg2 = static_cast< bool >(val2);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 (arg1)->SetCanVeto(arg2);
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_Py_Void();
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 PyObject *resultobj = 0;
24404 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24405 bool result;
24406 void *argp1 = 0 ;
24407 int res1 = 0 ;
24408 PyObject *swig_obj[1] ;
24409
24410 if (!args) SWIG_fail;
24411 swig_obj[0] = args;
24412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24415 }
24416 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24417 {
24418 PyThreadState* __tstate = wxPyBeginAllowThreads();
24419 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 {
24424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24425 }
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *obj;
24434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24435 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24436 return SWIG_Py_Void();
24437 }
24438
24439 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24440 return SWIG_Python_InitShadowInstance(args);
24441 }
24442
24443 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj = 0;
24445 int arg1 = (int) 0 ;
24446 bool arg2 = (bool) false ;
24447 wxShowEvent *result = 0 ;
24448 int val1 ;
24449 int ecode1 = 0 ;
24450 bool val2 ;
24451 int ecode2 = 0 ;
24452 PyObject * obj0 = 0 ;
24453 PyObject * obj1 = 0 ;
24454 char * kwnames[] = {
24455 (char *) "winid",(char *) "show", NULL
24456 };
24457
24458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24459 if (obj0) {
24460 ecode1 = SWIG_AsVal_int(obj0, &val1);
24461 if (!SWIG_IsOK(ecode1)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24463 }
24464 arg1 = static_cast< int >(val1);
24465 }
24466 if (obj1) {
24467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24468 if (!SWIG_IsOK(ecode2)) {
24469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24470 }
24471 arg2 = static_cast< bool >(val2);
24472 }
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj = 0;
24488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24489 bool arg2 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 bool val2 ;
24493 int ecode2 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 char * kwnames[] = {
24497 (char *) "self",(char *) "show", NULL
24498 };
24499
24500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24504 }
24505 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24509 }
24510 arg2 = static_cast< bool >(val2);
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 (arg1)->SetShow(arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_Py_Void();
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24527 bool result;
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_wxShowEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *obj;
24556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24557 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24558 return SWIG_Py_Void();
24559 }
24560
24561 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 return SWIG_Python_InitShadowInstance(args);
24563 }
24564
24565 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = 0;
24567 int arg1 = (int) 0 ;
24568 bool arg2 = (bool) true ;
24569 wxIconizeEvent *result = 0 ;
24570 int val1 ;
24571 int ecode1 = 0 ;
24572 bool val2 ;
24573 int ecode2 = 0 ;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char * kwnames[] = {
24577 (char *) "id",(char *) "iconized", NULL
24578 };
24579
24580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24581 if (obj0) {
24582 ecode1 = SWIG_AsVal_int(obj0, &val1);
24583 if (!SWIG_IsOK(ecode1)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24585 }
24586 arg1 = static_cast< int >(val1);
24587 }
24588 if (obj1) {
24589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24592 }
24593 arg2 = static_cast< bool >(val2);
24594 }
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24609 PyObject *resultobj = 0;
24610 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24611 bool result;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 PyObject *swig_obj[1] ;
24615
24616 if (!args) SWIG_fail;
24617 swig_obj[0] = args;
24618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24621 }
24622 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 result = (bool)(arg1)->Iconized();
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24639 PyObject *obj;
24640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24641 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24642 return SWIG_Py_Void();
24643 }
24644
24645 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 return SWIG_Python_InitShadowInstance(args);
24647 }
24648
24649 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj = 0;
24651 int arg1 = (int) 0 ;
24652 wxMaximizeEvent *result = 0 ;
24653 int val1 ;
24654 int ecode1 = 0 ;
24655 PyObject * obj0 = 0 ;
24656 char * kwnames[] = {
24657 (char *) "id", NULL
24658 };
24659
24660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24661 if (obj0) {
24662 ecode1 = SWIG_AsVal_int(obj0, &val1);
24663 if (!SWIG_IsOK(ecode1)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24665 }
24666 arg1 = static_cast< int >(val1);
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *obj;
24683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24684 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24685 return SWIG_Py_Void();
24686 }
24687
24688 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24689 return SWIG_Python_InitShadowInstance(args);
24690 }
24691
24692 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24695 wxPoint result;
24696 void *argp1 = 0 ;
24697 int res1 = 0 ;
24698 PyObject *swig_obj[1] ;
24699
24700 if (!args) SWIG_fail;
24701 swig_obj[0] = args;
24702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24705 }
24706 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (arg1)->GetPosition();
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721 PyObject *resultobj = 0;
24722 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24723 int result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 PyObject *swig_obj[1] ;
24727
24728 if (!args) SWIG_fail;
24729 swig_obj[0] = args;
24730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24733 }
24734 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (int)(arg1)->GetNumberOfFiles();
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_From_int(static_cast< int >(result));
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24751 PyObject *result = 0 ;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 PyObject *swig_obj[1] ;
24755
24756 if (!args) SWIG_fail;
24757 swig_obj[0] = args;
24758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24761 }
24762 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 resultobj = result;
24770 return resultobj;
24771 fail:
24772 return NULL;
24773 }
24774
24775
24776 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24777 PyObject *obj;
24778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24779 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24780 return SWIG_Py_Void();
24781 }
24782
24783 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj = 0;
24785 int arg1 = (int) 0 ;
24786 wxUpdateUIEvent *result = 0 ;
24787 int val1 ;
24788 int ecode1 = 0 ;
24789 PyObject * obj0 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "commandId", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24795 if (obj0) {
24796 ecode1 = SWIG_AsVal_int(obj0, &val1);
24797 if (!SWIG_IsOK(ecode1)) {
24798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24799 }
24800 arg1 = static_cast< int >(val1);
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24805 wxPyEndAllowThreads(__tstate);
24806 if (PyErr_Occurred()) SWIG_fail;
24807 }
24808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24816 PyObject *resultobj = 0;
24817 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24818 bool result;
24819 void *argp1 = 0 ;
24820 int res1 = 0 ;
24821 PyObject *swig_obj[1] ;
24822
24823 if (!args) SWIG_fail;
24824 swig_obj[0] = args;
24825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24826 if (!SWIG_IsOK(res1)) {
24827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24828 }
24829 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24830 {
24831 PyThreadState* __tstate = wxPyBeginAllowThreads();
24832 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24848 bool result;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 PyObject *swig_obj[1] ;
24852
24853 if (!args) SWIG_fail;
24854 swig_obj[0] = args;
24855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24858 }
24859 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 {
24867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24868 }
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24876 PyObject *resultobj = 0;
24877 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24878 bool result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 PyObject *swig_obj[1] ;
24882
24883 if (!args) SWIG_fail;
24884 swig_obj[0] = args;
24885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24886 if (!SWIG_IsOK(res1)) {
24887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24888 }
24889 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24898 }
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24906 PyObject *resultobj = 0;
24907 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24908 wxString result;
24909 void *argp1 = 0 ;
24910 int res1 = 0 ;
24911 PyObject *swig_obj[1] ;
24912
24913 if (!args) SWIG_fail;
24914 swig_obj[0] = args;
24915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24916 if (!SWIG_IsOK(res1)) {
24917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24918 }
24919 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 #if wxUSE_UNICODE
24928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24929 #else
24930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24931 #endif
24932 }
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24940 PyObject *resultobj = 0;
24941 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24942 bool result;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 PyObject *swig_obj[1] ;
24946
24947 if (!args) SWIG_fail;
24948 swig_obj[0] = args;
24949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24950 if (!SWIG_IsOK(res1)) {
24951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24952 }
24953 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 PyObject *resultobj = 0;
24971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24972 bool result;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 PyObject *swig_obj[1] ;
24976
24977 if (!args) SWIG_fail;
24978 swig_obj[0] = args;
24979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24980 if (!SWIG_IsOK(res1)) {
24981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24982 }
24983 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25000 PyObject *resultobj = 0;
25001 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25002 bool result;
25003 void *argp1 = 0 ;
25004 int res1 = 0 ;
25005 PyObject *swig_obj[1] ;
25006
25007 if (!args) SWIG_fail;
25008 swig_obj[0] = args;
25009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25012 }
25013 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25030 PyObject *resultobj = 0;
25031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25032 bool result;
25033 void *argp1 = 0 ;
25034 int res1 = 0 ;
25035 PyObject *swig_obj[1] ;
25036
25037 if (!args) SWIG_fail;
25038 swig_obj[0] = args;
25039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25042 }
25043 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25052 }
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj = 0;
25061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25062 bool arg2 ;
25063 void *argp1 = 0 ;
25064 int res1 = 0 ;
25065 bool val2 ;
25066 int ecode2 = 0 ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "check", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25077 }
25078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25082 }
25083 arg2 = static_cast< bool >(val2);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 (arg1)->Check(arg2);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25100 bool arg2 ;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 bool val2 ;
25104 int ecode2 = 0 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char * kwnames[] = {
25108 (char *) "self",(char *) "enable", NULL
25109 };
25110
25111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25118 if (!SWIG_IsOK(ecode2)) {
25119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25120 }
25121 arg2 = static_cast< bool >(val2);
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 (arg1)->Enable(arg2);
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 resultobj = SWIG_Py_Void();
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj = 0;
25137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25138 bool arg2 ;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 bool val2 ;
25142 int ecode2 = 0 ;
25143 PyObject * obj0 = 0 ;
25144 PyObject * obj1 = 0 ;
25145 char * kwnames[] = {
25146 (char *) "self",(char *) "show", NULL
25147 };
25148
25149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25153 }
25154 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25156 if (!SWIG_IsOK(ecode2)) {
25157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25158 }
25159 arg2 = static_cast< bool >(val2);
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 (arg1)->Show(arg2);
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 resultobj = SWIG_Py_Void();
25167 return resultobj;
25168 fail:
25169 return NULL;
25170 }
25171
25172
25173 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25174 PyObject *resultobj = 0;
25175 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25176 wxString *arg2 = 0 ;
25177 void *argp1 = 0 ;
25178 int res1 = 0 ;
25179 bool temp2 = false ;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 char * kwnames[] = {
25183 (char *) "self",(char *) "text", NULL
25184 };
25185
25186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25190 }
25191 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25192 {
25193 arg2 = wxString_in_helper(obj1);
25194 if (arg2 == NULL) SWIG_fail;
25195 temp2 = true;
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 (arg1)->SetText((wxString const &)*arg2);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_Py_Void();
25204 {
25205 if (temp2)
25206 delete arg2;
25207 }
25208 return resultobj;
25209 fail:
25210 {
25211 if (temp2)
25212 delete arg2;
25213 }
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 long arg1 ;
25221 long val1 ;
25222 int ecode1 = 0 ;
25223 PyObject * obj0 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "updateInterval", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25229 ecode1 = SWIG_AsVal_long(obj0, &val1);
25230 if (!SWIG_IsOK(ecode1)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25232 }
25233 arg1 = static_cast< long >(val1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxUpdateUIEvent::SetUpdateInterval(arg1);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 long result;
25250
25251 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_From_long(static_cast< long >(result));
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj = 0;
25267 wxWindow *arg1 = (wxWindow *) 0 ;
25268 bool result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 char * kwnames[] = {
25273 (char *) "win", NULL
25274 };
25275
25276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25278 if (!SWIG_IsOK(res1)) {
25279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25280 }
25281 arg1 = reinterpret_cast< wxWindow * >(argp1);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 {
25289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25290 }
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25298 PyObject *resultobj = 0;
25299
25300 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 wxUpdateUIEvent::ResetUpdateTime();
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 resultobj = SWIG_Py_Void();
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = 0;
25316 wxUpdateUIMode arg1 ;
25317 int val1 ;
25318 int ecode1 = 0 ;
25319 PyObject * obj0 = 0 ;
25320 char * kwnames[] = {
25321 (char *) "mode", NULL
25322 };
25323
25324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25325 ecode1 = SWIG_AsVal_int(obj0, &val1);
25326 if (!SWIG_IsOK(ecode1)) {
25327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25328 }
25329 arg1 = static_cast< wxUpdateUIMode >(val1);
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 wxUpdateUIEvent::SetMode(arg1);
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_Py_Void();
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25344 PyObject *resultobj = 0;
25345 wxUpdateUIMode result;
25346
25347 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 resultobj = SWIG_From_int(static_cast< int >(result));
25355 return resultobj;
25356 fail:
25357 return NULL;
25358 }
25359
25360
25361 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 PyObject *obj;
25363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25364 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25365 return SWIG_Py_Void();
25366 }
25367
25368 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25369 return SWIG_Python_InitShadowInstance(args);
25370 }
25371
25372 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25373 PyObject *resultobj = 0;
25374 wxSysColourChangedEvent *result = 0 ;
25375
25376 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25391 PyObject *obj;
25392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25393 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25394 return SWIG_Py_Void();
25395 }
25396
25397 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25398 return SWIG_Python_InitShadowInstance(args);
25399 }
25400
25401 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj = 0;
25403 int arg1 = (int) 0 ;
25404 wxWindow *arg2 = (wxWindow *) NULL ;
25405 wxMouseCaptureChangedEvent *result = 0 ;
25406 int val1 ;
25407 int ecode1 = 0 ;
25408 void *argp2 = 0 ;
25409 int res2 = 0 ;
25410 PyObject * obj0 = 0 ;
25411 PyObject * obj1 = 0 ;
25412 char * kwnames[] = {
25413 (char *) "winid",(char *) "gainedCapture", NULL
25414 };
25415
25416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25417 if (obj0) {
25418 ecode1 = SWIG_AsVal_int(obj0, &val1);
25419 if (!SWIG_IsOK(ecode1)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25421 }
25422 arg1 = static_cast< int >(val1);
25423 }
25424 if (obj1) {
25425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25426 if (!SWIG_IsOK(res2)) {
25427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25428 }
25429 arg2 = reinterpret_cast< wxWindow * >(argp2);
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25447 wxWindow *result = 0 ;
25448 void *argp1 = 0 ;
25449 int res1 = 0 ;
25450 PyObject *swig_obj[1] ;
25451
25452 if (!args) SWIG_fail;
25453 swig_obj[0] = args;
25454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25457 }
25458 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 {
25466 resultobj = wxPyMake_wxObject(result, (bool)0);
25467 }
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475 PyObject *obj;
25476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25477 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25478 return SWIG_Py_Void();
25479 }
25480
25481 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25482 return SWIG_Python_InitShadowInstance(args);
25483 }
25484
25485 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25486 PyObject *resultobj = 0;
25487 int arg1 = (int) 0 ;
25488 wxMouseCaptureLostEvent *result = 0 ;
25489 int val1 ;
25490 int ecode1 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 char * kwnames[] = {
25493 (char *) "winid", NULL
25494 };
25495
25496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25497 if (obj0) {
25498 ecode1 = SWIG_AsVal_int(obj0, &val1);
25499 if (!SWIG_IsOK(ecode1)) {
25500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25501 }
25502 arg1 = static_cast< int >(val1);
25503 }
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *obj;
25519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25520 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25521 return SWIG_Py_Void();
25522 }
25523
25524 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 return SWIG_Python_InitShadowInstance(args);
25526 }
25527
25528 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 PyObject *resultobj = 0;
25530 wxDisplayChangedEvent *result = 0 ;
25531
25532 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25547 PyObject *obj;
25548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25549 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25550 return SWIG_Py_Void();
25551 }
25552
25553 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 return SWIG_Python_InitShadowInstance(args);
25555 }
25556
25557 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25558 PyObject *resultobj = 0;
25559 int arg1 = (int) 0 ;
25560 wxPaletteChangedEvent *result = 0 ;
25561 int val1 ;
25562 int ecode1 = 0 ;
25563 PyObject * obj0 = 0 ;
25564 char * kwnames[] = {
25565 (char *) "id", NULL
25566 };
25567
25568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25569 if (obj0) {
25570 ecode1 = SWIG_AsVal_int(obj0, &val1);
25571 if (!SWIG_IsOK(ecode1)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25573 }
25574 arg1 = static_cast< int >(val1);
25575 }
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj = 0;
25591 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25592 wxWindow *arg2 = (wxWindow *) 0 ;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 void *argp2 = 0 ;
25596 int res2 = 0 ;
25597 PyObject * obj0 = 0 ;
25598 PyObject * obj1 = 0 ;
25599 char * kwnames[] = {
25600 (char *) "self",(char *) "win", NULL
25601 };
25602
25603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25610 if (!SWIG_IsOK(res2)) {
25611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25612 }
25613 arg2 = reinterpret_cast< wxWindow * >(argp2);
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 (arg1)->SetChangedWindow(arg2);
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 resultobj = SWIG_Py_Void();
25621 return resultobj;
25622 fail:
25623 return NULL;
25624 }
25625
25626
25627 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25628 PyObject *resultobj = 0;
25629 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25630 wxWindow *result = 0 ;
25631 void *argp1 = 0 ;
25632 int res1 = 0 ;
25633 PyObject *swig_obj[1] ;
25634
25635 if (!args) SWIG_fail;
25636 swig_obj[0] = args;
25637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25638 if (!SWIG_IsOK(res1)) {
25639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25640 }
25641 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 result = (wxWindow *)(arg1)->GetChangedWindow();
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 {
25649 resultobj = wxPyMake_wxObject(result, (bool)0);
25650 }
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *obj;
25659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25660 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25661 return SWIG_Py_Void();
25662 }
25663
25664 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 return SWIG_Python_InitShadowInstance(args);
25666 }
25667
25668 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj = 0;
25670 int arg1 = (int) 0 ;
25671 wxQueryNewPaletteEvent *result = 0 ;
25672 int val1 ;
25673 int ecode1 = 0 ;
25674 PyObject * obj0 = 0 ;
25675 char * kwnames[] = {
25676 (char *) "winid", NULL
25677 };
25678
25679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25680 if (obj0) {
25681 ecode1 = SWIG_AsVal_int(obj0, &val1);
25682 if (!SWIG_IsOK(ecode1)) {
25683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25684 }
25685 arg1 = static_cast< int >(val1);
25686 }
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25701 PyObject *resultobj = 0;
25702 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25703 bool arg2 ;
25704 void *argp1 = 0 ;
25705 int res1 = 0 ;
25706 bool val2 ;
25707 int ecode2 = 0 ;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 char * kwnames[] = {
25711 (char *) "self",(char *) "realized", NULL
25712 };
25713
25714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25721 if (!SWIG_IsOK(ecode2)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25723 }
25724 arg2 = static_cast< bool >(val2);
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 (arg1)->SetPaletteRealized(arg2);
25728 wxPyEndAllowThreads(__tstate);
25729 if (PyErr_Occurred()) SWIG_fail;
25730 }
25731 resultobj = SWIG_Py_Void();
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25739 PyObject *resultobj = 0;
25740 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25741 bool result;
25742 void *argp1 = 0 ;
25743 int res1 = 0 ;
25744 PyObject *swig_obj[1] ;
25745
25746 if (!args) SWIG_fail;
25747 swig_obj[0] = args;
25748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25751 }
25752 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 {
25760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25761 }
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25769 PyObject *obj;
25770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25771 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25772 return SWIG_Py_Void();
25773 }
25774
25775 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25776 return SWIG_Python_InitShadowInstance(args);
25777 }
25778
25779 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25780 PyObject *resultobj = 0;
25781 wxNavigationKeyEvent *result = 0 ;
25782
25783 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *resultobj = 0;
25799 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25800 bool result;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 PyObject *swig_obj[1] ;
25804
25805 if (!args) SWIG_fail;
25806 swig_obj[0] = args;
25807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25810 }
25811 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25830 bool arg2 ;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 bool val2 ;
25834 int ecode2 = 0 ;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "forward", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25845 }
25846 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25848 if (!SWIG_IsOK(ecode2)) {
25849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25850 }
25851 arg2 = static_cast< bool >(val2);
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 (arg1)->SetDirection(arg2);
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 resultobj = SWIG_Py_Void();
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25866 PyObject *resultobj = 0;
25867 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25868 bool result;
25869 void *argp1 = 0 ;
25870 int res1 = 0 ;
25871 PyObject *swig_obj[1] ;
25872
25873 if (!args) SWIG_fail;
25874 swig_obj[0] = args;
25875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25878 }
25879 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25880 {
25881 PyThreadState* __tstate = wxPyBeginAllowThreads();
25882 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 {
25887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25888 }
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = 0;
25897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25898 bool arg2 ;
25899 void *argp1 = 0 ;
25900 int res1 = 0 ;
25901 bool val2 ;
25902 int ecode2 = 0 ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 char * kwnames[] = {
25906 (char *) "self",(char *) "ischange", NULL
25907 };
25908
25909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25911 if (!SWIG_IsOK(res1)) {
25912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25913 }
25914 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25916 if (!SWIG_IsOK(ecode2)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25918 }
25919 arg2 = static_cast< bool >(val2);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 (arg1)->SetWindowChange(arg2);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_Py_Void();
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25934 PyObject *resultobj = 0;
25935 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25936 bool result;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 PyObject *swig_obj[1] ;
25940
25941 if (!args) SWIG_fail;
25942 swig_obj[0] = args;
25943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25946 }
25947 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 {
25955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25956 }
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj = 0;
25965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25966 bool arg2 ;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 bool val2 ;
25970 int ecode2 = 0 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "self",(char *) "bIs", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25981 }
25982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25984 if (!SWIG_IsOK(ecode2)) {
25985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25986 }
25987 arg2 = static_cast< bool >(val2);
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 (arg1)->SetFromTab(arg2);
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26004 long arg2 ;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 long val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "self",(char *) "flags", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26017 if (!SWIG_IsOK(res1)) {
26018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26019 }
26020 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26021 ecode2 = SWIG_AsVal_long(obj1, &val2);
26022 if (!SWIG_IsOK(ecode2)) {
26023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26024 }
26025 arg2 = static_cast< long >(val2);
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 (arg1)->SetFlags(arg2);
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 resultobj = SWIG_Py_Void();
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26040 PyObject *resultobj = 0;
26041 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26042 wxWindow *result = 0 ;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 PyObject *swig_obj[1] ;
26046
26047 if (!args) SWIG_fail;
26048 swig_obj[0] = args;
26049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26050 if (!SWIG_IsOK(res1)) {
26051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26052 }
26053 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26054 {
26055 PyThreadState* __tstate = wxPyBeginAllowThreads();
26056 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 {
26061 resultobj = wxPyMake_wxObject(result, (bool)0);
26062 }
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26072 wxWindow *arg2 = (wxWindow *) 0 ;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 void *argp2 = 0 ;
26076 int res2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "win", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26087 }
26088 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26090 if (!SWIG_IsOK(res2)) {
26091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26092 }
26093 arg2 = reinterpret_cast< wxWindow * >(argp2);
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 (arg1)->SetCurrentFocus(arg2);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *obj;
26109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26110 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26111 return SWIG_Py_Void();
26112 }
26113
26114 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26115 return SWIG_Python_InitShadowInstance(args);
26116 }
26117
26118 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26119 PyObject *resultobj = 0;
26120 wxWindow *arg1 = (wxWindow *) NULL ;
26121 wxWindowCreateEvent *result = 0 ;
26122 void *argp1 = 0 ;
26123 int res1 = 0 ;
26124 PyObject * obj0 = 0 ;
26125 char * kwnames[] = {
26126 (char *) "win", NULL
26127 };
26128
26129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26130 if (obj0) {
26131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26134 }
26135 arg1 = reinterpret_cast< wxWindow * >(argp1);
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26151 PyObject *resultobj = 0;
26152 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26153 wxWindow *result = 0 ;
26154 void *argp1 = 0 ;
26155 int res1 = 0 ;
26156 PyObject *swig_obj[1] ;
26157
26158 if (!args) SWIG_fail;
26159 swig_obj[0] = args;
26160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26163 }
26164 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 {
26172 resultobj = wxPyMake_wxObject(result, (bool)0);
26173 }
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 PyObject *obj;
26182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26183 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26184 return SWIG_Py_Void();
26185 }
26186
26187 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26188 return SWIG_Python_InitShadowInstance(args);
26189 }
26190
26191 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj = 0;
26193 wxWindow *arg1 = (wxWindow *) NULL ;
26194 wxWindowDestroyEvent *result = 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 PyObject * obj0 = 0 ;
26198 char * kwnames[] = {
26199 (char *) "win", NULL
26200 };
26201
26202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26203 if (obj0) {
26204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26205 if (!SWIG_IsOK(res1)) {
26206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26207 }
26208 arg1 = reinterpret_cast< wxWindow * >(argp1);
26209 }
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *resultobj = 0;
26225 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26226 wxWindow *result = 0 ;
26227 void *argp1 = 0 ;
26228 int res1 = 0 ;
26229 PyObject *swig_obj[1] ;
26230
26231 if (!args) SWIG_fail;
26232 swig_obj[0] = args;
26233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26234 if (!SWIG_IsOK(res1)) {
26235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26236 }
26237 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 {
26245 resultobj = wxPyMake_wxObject(result, (bool)0);
26246 }
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26254 PyObject *obj;
26255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26256 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26257 return SWIG_Py_Void();
26258 }
26259
26260 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 return SWIG_Python_InitShadowInstance(args);
26262 }
26263
26264 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26265 PyObject *resultobj = 0;
26266 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26267 int arg2 = (int) 0 ;
26268 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26269 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26270 wxContextMenuEvent *result = 0 ;
26271 int val1 ;
26272 int ecode1 = 0 ;
26273 int val2 ;
26274 int ecode2 = 0 ;
26275 wxPoint temp3 ;
26276 PyObject * obj0 = 0 ;
26277 PyObject * obj1 = 0 ;
26278 PyObject * obj2 = 0 ;
26279 char * kwnames[] = {
26280 (char *) "type",(char *) "winid",(char *) "pt", NULL
26281 };
26282
26283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26284 if (obj0) {
26285 ecode1 = SWIG_AsVal_int(obj0, &val1);
26286 if (!SWIG_IsOK(ecode1)) {
26287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26288 }
26289 arg1 = static_cast< wxEventType >(val1);
26290 }
26291 if (obj1) {
26292 ecode2 = SWIG_AsVal_int(obj1, &val2);
26293 if (!SWIG_IsOK(ecode2)) {
26294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26295 }
26296 arg2 = static_cast< int >(val2);
26297 }
26298 if (obj2) {
26299 {
26300 arg3 = &temp3;
26301 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26302 }
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 PyObject *resultobj = 0;
26319 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26320 wxPoint *result = 0 ;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 PyObject *swig_obj[1] ;
26324
26325 if (!args) SWIG_fail;
26326 swig_obj[0] = args;
26327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26330 }
26331 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 {
26335 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26336 result = (wxPoint *) &_result_ref;
26337 }
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj = 0;
26350 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26351 wxPoint *arg2 = 0 ;
26352 void *argp1 = 0 ;
26353 int res1 = 0 ;
26354 wxPoint temp2 ;
26355 PyObject * obj0 = 0 ;
26356 PyObject * obj1 = 0 ;
26357 char * kwnames[] = {
26358 (char *) "self",(char *) "pos", NULL
26359 };
26360
26361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26363 if (!SWIG_IsOK(res1)) {
26364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26365 }
26366 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26367 {
26368 arg2 = &temp2;
26369 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26370 }
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 (arg1)->SetPosition((wxPoint const &)*arg2);
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 resultobj = SWIG_Py_Void();
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 PyObject *obj;
26386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26387 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26388 return SWIG_Py_Void();
26389 }
26390
26391 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26392 return SWIG_Python_InitShadowInstance(args);
26393 }
26394
26395 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26396 PyObject *resultobj = 0;
26397 wxIdleEvent *result = 0 ;
26398
26399 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 result = (wxIdleEvent *)new wxIdleEvent();
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26407 return resultobj;
26408 fail:
26409 return NULL;
26410 }
26411
26412
26413 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26414 PyObject *resultobj = 0;
26415 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26416 bool arg2 = (bool) true ;
26417 void *argp1 = 0 ;
26418 int res1 = 0 ;
26419 bool val2 ;
26420 int ecode2 = 0 ;
26421 PyObject * obj0 = 0 ;
26422 PyObject * obj1 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "self",(char *) "needMore", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26429 if (!SWIG_IsOK(res1)) {
26430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26431 }
26432 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26433 if (obj1) {
26434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26435 if (!SWIG_IsOK(ecode2)) {
26436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26437 }
26438 arg2 = static_cast< bool >(val2);
26439 }
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 (arg1)->RequestMore(arg2);
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_Py_Void();
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26454 PyObject *resultobj = 0;
26455 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26456 bool result;
26457 void *argp1 = 0 ;
26458 int res1 = 0 ;
26459 PyObject *swig_obj[1] ;
26460
26461 if (!args) SWIG_fail;
26462 swig_obj[0] = args;
26463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26464 if (!SWIG_IsOK(res1)) {
26465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26466 }
26467 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 {
26475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26476 }
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxIdleMode arg1 ;
26486 int val1 ;
26487 int ecode1 = 0 ;
26488 PyObject * obj0 = 0 ;
26489 char * kwnames[] = {
26490 (char *) "mode", NULL
26491 };
26492
26493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26494 ecode1 = SWIG_AsVal_int(obj0, &val1);
26495 if (!SWIG_IsOK(ecode1)) {
26496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26497 }
26498 arg1 = static_cast< wxIdleMode >(val1);
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 wxIdleEvent::SetMode(arg1);
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 resultobj = SWIG_Py_Void();
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 PyObject *resultobj = 0;
26514 wxIdleMode result;
26515
26516 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = (wxIdleMode)wxIdleEvent::GetMode();
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_From_int(static_cast< int >(result));
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj = 0;
26532 wxWindow *arg1 = (wxWindow *) 0 ;
26533 bool result;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 PyObject * obj0 = 0 ;
26537 char * kwnames[] = {
26538 (char *) "win", NULL
26539 };
26540
26541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26545 }
26546 arg1 = reinterpret_cast< wxWindow * >(argp1);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (bool)wxIdleEvent::CanSend(arg1);
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26555 }
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *obj;
26564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26565 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26566 return SWIG_Py_Void();
26567 }
26568
26569 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 return SWIG_Python_InitShadowInstance(args);
26571 }
26572
26573 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj = 0;
26575 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26576 int arg2 = (int) 0 ;
26577 wxClipboardTextEvent *result = 0 ;
26578 int val1 ;
26579 int ecode1 = 0 ;
26580 int val2 ;
26581 int ecode2 = 0 ;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "type",(char *) "winid", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26589 if (obj0) {
26590 ecode1 = SWIG_AsVal_int(obj0, &val1);
26591 if (!SWIG_IsOK(ecode1)) {
26592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26593 }
26594 arg1 = static_cast< wxEventType >(val1);
26595 }
26596 if (obj1) {
26597 ecode2 = SWIG_AsVal_int(obj1, &val2);
26598 if (!SWIG_IsOK(ecode2)) {
26599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26600 }
26601 arg2 = static_cast< int >(val2);
26602 }
26603 {
26604 PyThreadState* __tstate = wxPyBeginAllowThreads();
26605 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26617 PyObject *obj;
26618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26619 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26620 return SWIG_Py_Void();
26621 }
26622
26623 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26624 return SWIG_Python_InitShadowInstance(args);
26625 }
26626
26627 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj = 0;
26629 int arg1 = (int) 0 ;
26630 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26631 wxPyEvent *result = 0 ;
26632 int val1 ;
26633 int ecode1 = 0 ;
26634 int val2 ;
26635 int ecode2 = 0 ;
26636 PyObject * obj0 = 0 ;
26637 PyObject * obj1 = 0 ;
26638 char * kwnames[] = {
26639 (char *) "winid",(char *) "eventType", NULL
26640 };
26641
26642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26643 if (obj0) {
26644 ecode1 = SWIG_AsVal_int(obj0, &val1);
26645 if (!SWIG_IsOK(ecode1)) {
26646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26647 }
26648 arg1 = static_cast< int >(val1);
26649 }
26650 if (obj1) {
26651 ecode2 = SWIG_AsVal_int(obj1, &val2);
26652 if (!SWIG_IsOK(ecode2)) {
26653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26654 }
26655 arg2 = static_cast< wxEventType >(val2);
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 PyObject *resultobj = 0;
26672 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26673 void *argp1 = 0 ;
26674 int res1 = 0 ;
26675 PyObject *swig_obj[1] ;
26676
26677 if (!args) SWIG_fail;
26678 swig_obj[0] = args;
26679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26682 }
26683 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 delete arg1;
26687
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_Py_Void();
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj = 0;
26700 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26701 PyObject *arg2 = (PyObject *) 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject * obj0 = 0 ;
26705 PyObject * obj1 = 0 ;
26706 char * kwnames[] = {
26707 (char *) "self",(char *) "self", NULL
26708 };
26709
26710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26714 }
26715 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26716 arg2 = obj1;
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 (arg1)->SetSelf(arg2);
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 resultobj = SWIG_Py_Void();
26724 return resultobj;
26725 fail:
26726 return NULL;
26727 }
26728
26729
26730 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26731 PyObject *resultobj = 0;
26732 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26733 PyObject *result = 0 ;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 PyObject *swig_obj[1] ;
26737
26738 if (!args) SWIG_fail;
26739 swig_obj[0] = args;
26740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26743 }
26744 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 result = (PyObject *)(arg1)->GetSelf();
26748 wxPyEndAllowThreads(__tstate);
26749 if (PyErr_Occurred()) SWIG_fail;
26750 }
26751 resultobj = result;
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *obj;
26760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26761 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26762 return SWIG_Py_Void();
26763 }
26764
26765 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 return SWIG_Python_InitShadowInstance(args);
26767 }
26768
26769 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26772 int arg2 = (int) 0 ;
26773 wxPyCommandEvent *result = 0 ;
26774 int val1 ;
26775 int ecode1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "eventType",(char *) "id", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26785 if (obj0) {
26786 ecode1 = SWIG_AsVal_int(obj0, &val1);
26787 if (!SWIG_IsOK(ecode1)) {
26788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26789 }
26790 arg1 = static_cast< wxEventType >(val1);
26791 }
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_int(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26796 }
26797 arg2 = static_cast< int >(val2);
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *resultobj = 0;
26814 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 PyObject *swig_obj[1] ;
26818
26819 if (!args) SWIG_fail;
26820 swig_obj[0] = args;
26821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26824 }
26825 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 delete arg1;
26829
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 resultobj = SWIG_Py_Void();
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26843 PyObject *arg2 = (PyObject *) 0 ;
26844 void *argp1 = 0 ;
26845 int res1 = 0 ;
26846 PyObject * obj0 = 0 ;
26847 PyObject * obj1 = 0 ;
26848 char * kwnames[] = {
26849 (char *) "self",(char *) "self", NULL
26850 };
26851
26852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26854 if (!SWIG_IsOK(res1)) {
26855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26856 }
26857 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26858 arg2 = obj1;
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 (arg1)->SetSelf(arg2);
26862 wxPyEndAllowThreads(__tstate);
26863 if (PyErr_Occurred()) SWIG_fail;
26864 }
26865 resultobj = SWIG_Py_Void();
26866 return resultobj;
26867 fail:
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 PyObject *resultobj = 0;
26874 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26875 PyObject *result = 0 ;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 PyObject *swig_obj[1] ;
26879
26880 if (!args) SWIG_fail;
26881 swig_obj[0] = args;
26882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26883 if (!SWIG_IsOK(res1)) {
26884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26885 }
26886 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = (PyObject *)(arg1)->GetSelf();
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 resultobj = result;
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26901 PyObject *obj;
26902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26903 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26904 return SWIG_Py_Void();
26905 }
26906
26907 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 return SWIG_Python_InitShadowInstance(args);
26909 }
26910
26911 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj = 0;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 wxDateTime *arg2 = 0 ;
26915 wxEventType arg3 ;
26916 wxDateEvent *result = 0 ;
26917 void *argp1 = 0 ;
26918 int res1 = 0 ;
26919 void *argp2 = 0 ;
26920 int res2 = 0 ;
26921 int val3 ;
26922 int ecode3 = 0 ;
26923 PyObject * obj0 = 0 ;
26924 PyObject * obj1 = 0 ;
26925 PyObject * obj2 = 0 ;
26926 char * kwnames[] = {
26927 (char *) "win",(char *) "dt",(char *) "type", NULL
26928 };
26929
26930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26932 if (!SWIG_IsOK(res1)) {
26933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26934 }
26935 arg1 = reinterpret_cast< wxWindow * >(argp1);
26936 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26937 if (!SWIG_IsOK(res2)) {
26938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26939 }
26940 if (!argp2) {
26941 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26942 }
26943 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26944 ecode3 = SWIG_AsVal_int(obj2, &val3);
26945 if (!SWIG_IsOK(ecode3)) {
26946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26947 }
26948 arg3 = static_cast< wxEventType >(val3);
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 PyObject *resultobj = 0;
26964 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26965 wxDateTime *result = 0 ;
26966 void *argp1 = 0 ;
26967 int res1 = 0 ;
26968 PyObject *swig_obj[1] ;
26969
26970 if (!args) SWIG_fail;
26971 swig_obj[0] = args;
26972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26975 }
26976 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 {
26980 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26981 result = (wxDateTime *) &_result_ref;
26982 }
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = 0;
26995 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26996 wxDateTime *arg2 = 0 ;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 void *argp2 = 0 ;
27000 int res2 = 0 ;
27001 PyObject * obj0 = 0 ;
27002 PyObject * obj1 = 0 ;
27003 char * kwnames[] = {
27004 (char *) "self",(char *) "date", NULL
27005 };
27006
27007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27011 }
27012 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27014 if (!SWIG_IsOK(res2)) {
27015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27016 }
27017 if (!argp2) {
27018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27019 }
27020 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 (arg1)->SetDate((wxDateTime const &)*arg2);
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 resultobj = SWIG_Py_Void();
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27035 PyObject *obj;
27036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27037 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27038 return SWIG_Py_Void();
27039 }
27040
27041 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 return SWIG_Python_InitShadowInstance(args);
27043 }
27044
27045 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxPyApp *result = 0 ;
27048
27049 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 result = (wxPyApp *)new_wxPyApp();
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 void *argp1 = 0 ;
27067 int res1 = 0 ;
27068 PyObject *swig_obj[1] ;
27069
27070 if (!args) SWIG_fail;
27071 swig_obj[0] = args;
27072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27075 }
27076 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 delete arg1;
27080
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 resultobj = SWIG_Py_Void();
27085 return resultobj;
27086 fail:
27087 return NULL;
27088 }
27089
27090
27091 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27092 PyObject *resultobj = 0;
27093 wxPyApp *arg1 = (wxPyApp *) 0 ;
27094 PyObject *arg2 = (PyObject *) 0 ;
27095 PyObject *arg3 = (PyObject *) 0 ;
27096 bool arg4 ;
27097 void *argp1 = 0 ;
27098 int res1 = 0 ;
27099 bool val4 ;
27100 int ecode4 = 0 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 PyObject * obj2 = 0 ;
27104 PyObject * obj3 = 0 ;
27105 char * kwnames[] = {
27106 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27107 };
27108
27109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27111 if (!SWIG_IsOK(res1)) {
27112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27113 }
27114 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27115 arg2 = obj1;
27116 arg3 = obj2;
27117 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27118 if (!SWIG_IsOK(ecode4)) {
27119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27120 }
27121 arg4 = static_cast< bool >(val4);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 resultobj = SWIG_Py_Void();
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27136 PyObject *resultobj = 0;
27137 wxPyApp *arg1 = (wxPyApp *) 0 ;
27138 wxString result;
27139 void *argp1 = 0 ;
27140 int res1 = 0 ;
27141 PyObject *swig_obj[1] ;
27142
27143 if (!args) SWIG_fail;
27144 swig_obj[0] = args;
27145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27146 if (!SWIG_IsOK(res1)) {
27147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27148 }
27149 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 result = ((wxPyApp const *)arg1)->GetAppName();
27153 wxPyEndAllowThreads(__tstate);
27154 if (PyErr_Occurred()) SWIG_fail;
27155 }
27156 {
27157 #if wxUSE_UNICODE
27158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27159 #else
27160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27161 #endif
27162 }
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27170 PyObject *resultobj = 0;
27171 wxPyApp *arg1 = (wxPyApp *) 0 ;
27172 wxString *arg2 = 0 ;
27173 void *argp1 = 0 ;
27174 int res1 = 0 ;
27175 bool temp2 = false ;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char * kwnames[] = {
27179 (char *) "self",(char *) "name", NULL
27180 };
27181
27182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27184 if (!SWIG_IsOK(res1)) {
27185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27186 }
27187 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27188 {
27189 arg2 = wxString_in_helper(obj1);
27190 if (arg2 == NULL) SWIG_fail;
27191 temp2 = true;
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 (arg1)->SetAppName((wxString const &)*arg2);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 resultobj = SWIG_Py_Void();
27200 {
27201 if (temp2)
27202 delete arg2;
27203 }
27204 return resultobj;
27205 fail:
27206 {
27207 if (temp2)
27208 delete arg2;
27209 }
27210 return NULL;
27211 }
27212
27213
27214 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27215 PyObject *resultobj = 0;
27216 wxPyApp *arg1 = (wxPyApp *) 0 ;
27217 wxString result;
27218 void *argp1 = 0 ;
27219 int res1 = 0 ;
27220 PyObject *swig_obj[1] ;
27221
27222 if (!args) SWIG_fail;
27223 swig_obj[0] = args;
27224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27225 if (!SWIG_IsOK(res1)) {
27226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27227 }
27228 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = ((wxPyApp const *)arg1)->GetClassName();
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 {
27236 #if wxUSE_UNICODE
27237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27238 #else
27239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27240 #endif
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj = 0;
27250 wxPyApp *arg1 = (wxPyApp *) 0 ;
27251 wxString *arg2 = 0 ;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 bool temp2 = false ;
27255 PyObject * obj0 = 0 ;
27256 PyObject * obj1 = 0 ;
27257 char * kwnames[] = {
27258 (char *) "self",(char *) "name", NULL
27259 };
27260
27261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27263 if (!SWIG_IsOK(res1)) {
27264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27265 }
27266 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27267 {
27268 arg2 = wxString_in_helper(obj1);
27269 if (arg2 == NULL) SWIG_fail;
27270 temp2 = true;
27271 }
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 (arg1)->SetClassName((wxString const &)*arg2);
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 resultobj = SWIG_Py_Void();
27279 {
27280 if (temp2)
27281 delete arg2;
27282 }
27283 return resultobj;
27284 fail:
27285 {
27286 if (temp2)
27287 delete arg2;
27288 }
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27294 PyObject *resultobj = 0;
27295 wxPyApp *arg1 = (wxPyApp *) 0 ;
27296 wxString *result = 0 ;
27297 void *argp1 = 0 ;
27298 int res1 = 0 ;
27299 PyObject *swig_obj[1] ;
27300
27301 if (!args) SWIG_fail;
27302 swig_obj[0] = args;
27303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27304 if (!SWIG_IsOK(res1)) {
27305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27306 }
27307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 {
27311 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27312 result = (wxString *) &_result_ref;
27313 }
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 #if wxUSE_UNICODE
27319 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27320 #else
27321 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27322 #endif
27323 }
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27331 PyObject *resultobj = 0;
27332 wxPyApp *arg1 = (wxPyApp *) 0 ;
27333 wxString *arg2 = 0 ;
27334 void *argp1 = 0 ;
27335 int res1 = 0 ;
27336 bool temp2 = false ;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char * kwnames[] = {
27340 (char *) "self",(char *) "name", NULL
27341 };
27342
27343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27347 }
27348 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27349 {
27350 arg2 = wxString_in_helper(obj1);
27351 if (arg2 == NULL) SWIG_fail;
27352 temp2 = true;
27353 }
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 (arg1)->SetVendorName((wxString const &)*arg2);
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_Py_Void();
27361 {
27362 if (temp2)
27363 delete arg2;
27364 }
27365 return resultobj;
27366 fail:
27367 {
27368 if (temp2)
27369 delete arg2;
27370 }
27371 return NULL;
27372 }
27373
27374
27375 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27376 PyObject *resultobj = 0;
27377 wxPyApp *arg1 = (wxPyApp *) 0 ;
27378 wxAppTraits *result = 0 ;
27379 void *argp1 = 0 ;
27380 int res1 = 0 ;
27381 PyObject *swig_obj[1] ;
27382
27383 if (!args) SWIG_fail;
27384 swig_obj[0] = args;
27385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27386 if (!SWIG_IsOK(res1)) {
27387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27388 }
27389 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (wxAppTraits *)(arg1)->GetTraits();
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 PyObject *resultobj = 0;
27405 wxPyApp *arg1 = (wxPyApp *) 0 ;
27406 void *argp1 = 0 ;
27407 int res1 = 0 ;
27408 PyObject *swig_obj[1] ;
27409
27410 if (!args) SWIG_fail;
27411 swig_obj[0] = args;
27412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27413 if (!SWIG_IsOK(res1)) {
27414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27415 }
27416 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 (arg1)->ProcessPendingEvents();
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_Py_Void();
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 bool arg2 = (bool) false ;
27434 bool result;
27435 void *argp1 = 0 ;
27436 int res1 = 0 ;
27437 bool val2 ;
27438 int ecode2 = 0 ;
27439 PyObject * obj0 = 0 ;
27440 PyObject * obj1 = 0 ;
27441 char * kwnames[] = {
27442 (char *) "self",(char *) "onlyIfNeeded", NULL
27443 };
27444
27445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27447 if (!SWIG_IsOK(res1)) {
27448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27449 }
27450 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27451 if (obj1) {
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)(arg1)->Yield(arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27466 }
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27474 PyObject *resultobj = 0;
27475 wxPyApp *arg1 = (wxPyApp *) 0 ;
27476 void *argp1 = 0 ;
27477 int res1 = 0 ;
27478 PyObject *swig_obj[1] ;
27479
27480 if (!args) SWIG_fail;
27481 swig_obj[0] = args;
27482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27483 if (!SWIG_IsOK(res1)) {
27484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27485 }
27486 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 (arg1)->WakeUpIdle();
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 resultobj = SWIG_Py_Void();
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *resultobj = 0;
27502 bool result;
27503
27504 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (bool)wxPyApp::IsMainLoopRunning();
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 {
27512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27513 }
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27521 PyObject *resultobj = 0;
27522 wxPyApp *arg1 = (wxPyApp *) 0 ;
27523 int result;
27524 void *argp1 = 0 ;
27525 int res1 = 0 ;
27526 PyObject *swig_obj[1] ;
27527
27528 if (!args) SWIG_fail;
27529 swig_obj[0] = args;
27530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27531 if (!SWIG_IsOK(res1)) {
27532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27533 }
27534 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = (int)(arg1)->MainLoop();
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_From_int(static_cast< int >(result));
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 PyObject *resultobj = 0;
27550 wxPyApp *arg1 = (wxPyApp *) 0 ;
27551 void *argp1 = 0 ;
27552 int res1 = 0 ;
27553 PyObject *swig_obj[1] ;
27554
27555 if (!args) SWIG_fail;
27556 swig_obj[0] = args;
27557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27558 if (!SWIG_IsOK(res1)) {
27559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27560 }
27561 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->Exit();
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_Py_Void();
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27576 PyObject *resultobj = 0;
27577 wxPyApp *arg1 = (wxPyApp *) 0 ;
27578 void *argp1 = 0 ;
27579 int res1 = 0 ;
27580 PyObject *swig_obj[1] ;
27581
27582 if (!args) SWIG_fail;
27583 swig_obj[0] = args;
27584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27587 }
27588 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 (arg1)->ExitMainLoop();
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 resultobj = SWIG_Py_Void();
27596 return resultobj;
27597 fail:
27598 return NULL;
27599 }
27600
27601
27602 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27603 PyObject *resultobj = 0;
27604 wxPyApp *arg1 = (wxPyApp *) 0 ;
27605 bool result;
27606 void *argp1 = 0 ;
27607 int res1 = 0 ;
27608 PyObject *swig_obj[1] ;
27609
27610 if (!args) SWIG_fail;
27611 swig_obj[0] = args;
27612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27613 if (!SWIG_IsOK(res1)) {
27614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27615 }
27616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 result = (bool)(arg1)->Pending();
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633 PyObject *resultobj = 0;
27634 wxPyApp *arg1 = (wxPyApp *) 0 ;
27635 bool result;
27636 void *argp1 = 0 ;
27637 int res1 = 0 ;
27638 PyObject *swig_obj[1] ;
27639
27640 if (!args) SWIG_fail;
27641 swig_obj[0] = args;
27642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27643 if (!SWIG_IsOK(res1)) {
27644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27645 }
27646 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27647 {
27648 PyThreadState* __tstate = wxPyBeginAllowThreads();
27649 result = (bool)(arg1)->Dispatch();
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 {
27654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27655 }
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxPyApp *arg1 = (wxPyApp *) 0 ;
27665 bool result;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27675 }
27676 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (bool)(arg1)->ProcessIdle();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27693 PyObject *resultobj = 0;
27694 wxPyApp *arg1 = (wxPyApp *) 0 ;
27695 wxWindow *arg2 = (wxWindow *) 0 ;
27696 wxIdleEvent *arg3 = 0 ;
27697 bool result;
27698 void *argp1 = 0 ;
27699 int res1 = 0 ;
27700 void *argp2 = 0 ;
27701 int res2 = 0 ;
27702 void *argp3 = 0 ;
27703 int res3 = 0 ;
27704 PyObject * obj0 = 0 ;
27705 PyObject * obj1 = 0 ;
27706 PyObject * obj2 = 0 ;
27707 char * kwnames[] = {
27708 (char *) "self",(char *) "win",(char *) "event", NULL
27709 };
27710
27711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27718 if (!SWIG_IsOK(res2)) {
27719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27720 }
27721 arg2 = reinterpret_cast< wxWindow * >(argp2);
27722 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27723 if (!SWIG_IsOK(res3)) {
27724 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27725 }
27726 if (!argp3) {
27727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27728 }
27729 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 {
27737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27738 }
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 bool result;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27758 }
27759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 result = (bool)((wxPyApp const *)arg1)->IsActive();
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 {
27767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj = 0;
27777 wxPyApp *arg1 = (wxPyApp *) 0 ;
27778 wxWindow *arg2 = (wxWindow *) 0 ;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 void *argp2 = 0 ;
27782 int res2 = 0 ;
27783 PyObject * obj0 = 0 ;
27784 PyObject * obj1 = 0 ;
27785 char * kwnames[] = {
27786 (char *) "self",(char *) "win", NULL
27787 };
27788
27789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27791 if (!SWIG_IsOK(res1)) {
27792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27793 }
27794 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27796 if (!SWIG_IsOK(res2)) {
27797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27798 }
27799 arg2 = reinterpret_cast< wxWindow * >(argp2);
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 (arg1)->SetTopWindow(arg2);
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 resultobj = SWIG_Py_Void();
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27814 PyObject *resultobj = 0;
27815 wxPyApp *arg1 = (wxPyApp *) 0 ;
27816 wxWindow *result = 0 ;
27817 void *argp1 = 0 ;
27818 int res1 = 0 ;
27819 PyObject *swig_obj[1] ;
27820
27821 if (!args) SWIG_fail;
27822 swig_obj[0] = args;
27823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27824 if (!SWIG_IsOK(res1)) {
27825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27826 }
27827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27831 wxPyEndAllowThreads(__tstate);
27832 if (PyErr_Occurred()) SWIG_fail;
27833 }
27834 {
27835 resultobj = wxPyMake_wxObject(result, (bool)0);
27836 }
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj = 0;
27845 wxPyApp *arg1 = (wxPyApp *) 0 ;
27846 bool arg2 ;
27847 void *argp1 = 0 ;
27848 int res1 = 0 ;
27849 bool val2 ;
27850 int ecode2 = 0 ;
27851 PyObject * obj0 = 0 ;
27852 PyObject * obj1 = 0 ;
27853 char * kwnames[] = {
27854 (char *) "self",(char *) "flag", NULL
27855 };
27856
27857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27859 if (!SWIG_IsOK(res1)) {
27860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27861 }
27862 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27864 if (!SWIG_IsOK(ecode2)) {
27865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27866 }
27867 arg2 = static_cast< bool >(val2);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 (arg1)->SetExitOnFrameDelete(arg2);
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = SWIG_Py_Void();
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27882 PyObject *resultobj = 0;
27883 wxPyApp *arg1 = (wxPyApp *) 0 ;
27884 bool result;
27885 void *argp1 = 0 ;
27886 int res1 = 0 ;
27887 PyObject *swig_obj[1] ;
27888
27889 if (!args) SWIG_fail;
27890 swig_obj[0] = args;
27891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27894 }
27895 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27899 wxPyEndAllowThreads(__tstate);
27900 if (PyErr_Occurred()) SWIG_fail;
27901 }
27902 {
27903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27904 }
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27912 PyObject *resultobj = 0;
27913 wxPyApp *arg1 = (wxPyApp *) 0 ;
27914 bool arg2 ;
27915 void *argp1 = 0 ;
27916 int res1 = 0 ;
27917 bool val2 ;
27918 int ecode2 = 0 ;
27919 PyObject * obj0 = 0 ;
27920 PyObject * obj1 = 0 ;
27921 char * kwnames[] = {
27922 (char *) "self",(char *) "flag", NULL
27923 };
27924
27925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27927 if (!SWIG_IsOK(res1)) {
27928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27929 }
27930 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27932 if (!SWIG_IsOK(ecode2)) {
27933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27934 }
27935 arg2 = static_cast< bool >(val2);
27936 {
27937 PyThreadState* __tstate = wxPyBeginAllowThreads();
27938 (arg1)->SetUseBestVisual(arg2);
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 resultobj = SWIG_Py_Void();
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27950 PyObject *resultobj = 0;
27951 wxPyApp *arg1 = (wxPyApp *) 0 ;
27952 bool result;
27953 void *argp1 = 0 ;
27954 int res1 = 0 ;
27955 PyObject *swig_obj[1] ;
27956
27957 if (!args) SWIG_fail;
27958 swig_obj[0] = args;
27959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27962 }
27963 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 {
27971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27972 }
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27980 PyObject *resultobj = 0;
27981 wxPyApp *arg1 = (wxPyApp *) 0 ;
27982 int arg2 ;
27983 void *argp1 = 0 ;
27984 int res1 = 0 ;
27985 int val2 ;
27986 int ecode2 = 0 ;
27987 PyObject * obj0 = 0 ;
27988 PyObject * obj1 = 0 ;
27989 char * kwnames[] = {
27990 (char *) "self",(char *) "mode", NULL
27991 };
27992
27993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27995 if (!SWIG_IsOK(res1)) {
27996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27997 }
27998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27999 ecode2 = SWIG_AsVal_int(obj1, &val2);
28000 if (!SWIG_IsOK(ecode2)) {
28001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28002 }
28003 arg2 = static_cast< int >(val2);
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 (arg1)->SetPrintMode(arg2);
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_Py_Void();
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28018 PyObject *resultobj = 0;
28019 wxPyApp *arg1 = (wxPyApp *) 0 ;
28020 int result;
28021 void *argp1 = 0 ;
28022 int res1 = 0 ;
28023 PyObject *swig_obj[1] ;
28024
28025 if (!args) SWIG_fail;
28026 swig_obj[0] = args;
28027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28028 if (!SWIG_IsOK(res1)) {
28029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28030 }
28031 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 resultobj = SWIG_From_int(static_cast< int >(result));
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 wxPyApp *arg1 = (wxPyApp *) 0 ;
28048 int arg2 ;
28049 void *argp1 = 0 ;
28050 int res1 = 0 ;
28051 int val2 ;
28052 int ecode2 = 0 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char * kwnames[] = {
28056 (char *) "self",(char *) "mode", NULL
28057 };
28058
28059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28061 if (!SWIG_IsOK(res1)) {
28062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28063 }
28064 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28065 ecode2 = SWIG_AsVal_int(obj1, &val2);
28066 if (!SWIG_IsOK(ecode2)) {
28067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28068 }
28069 arg2 = static_cast< int >(val2);
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 (arg1)->SetAssertMode(arg2);
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 resultobj = SWIG_Py_Void();
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28084 PyObject *resultobj = 0;
28085 wxPyApp *arg1 = (wxPyApp *) 0 ;
28086 int result;
28087 void *argp1 = 0 ;
28088 int res1 = 0 ;
28089 PyObject *swig_obj[1] ;
28090
28091 if (!args) SWIG_fail;
28092 swig_obj[0] = args;
28093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28094 if (!SWIG_IsOK(res1)) {
28095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28096 }
28097 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = (int)(arg1)->GetAssertMode();
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 resultobj = SWIG_From_int(static_cast< int >(result));
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28112 PyObject *resultobj = 0;
28113 bool result;
28114
28115 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28119 wxPyEndAllowThreads(__tstate);
28120 if (PyErr_Occurred()) SWIG_fail;
28121 }
28122 {
28123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28124 }
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28132 PyObject *resultobj = 0;
28133 long result;
28134
28135 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 result = (long)wxPyApp::GetMacAboutMenuItemId();
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 resultobj = SWIG_From_long(static_cast< long >(result));
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28150 PyObject *resultobj = 0;
28151 long result;
28152
28153 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 resultobj = SWIG_From_long(static_cast< long >(result));
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169 long result;
28170
28171 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = (long)wxPyApp::GetMacExitMenuItemId();
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_From_long(static_cast< long >(result));
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28186 PyObject *resultobj = 0;
28187 wxString result;
28188
28189 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = wxPyApp::GetMacHelpMenuTitleName();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 {
28197 #if wxUSE_UNICODE
28198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28199 #else
28200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28201 #endif
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = 0;
28211 bool arg1 ;
28212 bool val1 ;
28213 int ecode1 = 0 ;
28214 PyObject * obj0 = 0 ;
28215 char * kwnames[] = {
28216 (char *) "val", NULL
28217 };
28218
28219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28220 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28221 if (!SWIG_IsOK(ecode1)) {
28222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28223 }
28224 arg1 = static_cast< bool >(val1);
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 resultobj = SWIG_Py_Void();
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj = 0;
28240 long arg1 ;
28241 long val1 ;
28242 int ecode1 = 0 ;
28243 PyObject * obj0 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "val", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28249 ecode1 = SWIG_AsVal_long(obj0, &val1);
28250 if (!SWIG_IsOK(ecode1)) {
28251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28252 }
28253 arg1 = static_cast< long >(val1);
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 wxPyApp::SetMacAboutMenuItemId(arg1);
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 resultobj = SWIG_Py_Void();
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj = 0;
28269 long arg1 ;
28270 long val1 ;
28271 int ecode1 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "val", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28278 ecode1 = SWIG_AsVal_long(obj0, &val1);
28279 if (!SWIG_IsOK(ecode1)) {
28280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28281 }
28282 arg1 = static_cast< long >(val1);
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_Py_Void();
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj = 0;
28298 long arg1 ;
28299 long val1 ;
28300 int ecode1 = 0 ;
28301 PyObject * obj0 = 0 ;
28302 char * kwnames[] = {
28303 (char *) "val", NULL
28304 };
28305
28306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28307 ecode1 = SWIG_AsVal_long(obj0, &val1);
28308 if (!SWIG_IsOK(ecode1)) {
28309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28310 }
28311 arg1 = static_cast< long >(val1);
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 wxPyApp::SetMacExitMenuItemId(arg1);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_Py_Void();
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj = 0;
28327 wxString *arg1 = 0 ;
28328 bool temp1 = false ;
28329 PyObject * obj0 = 0 ;
28330 char * kwnames[] = {
28331 (char *) "val", NULL
28332 };
28333
28334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28335 {
28336 arg1 = wxString_in_helper(obj0);
28337 if (arg1 == NULL) SWIG_fail;
28338 temp1 = true;
28339 }
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_Py_Void();
28347 {
28348 if (temp1)
28349 delete arg1;
28350 }
28351 return resultobj;
28352 fail:
28353 {
28354 if (temp1)
28355 delete arg1;
28356 }
28357 return NULL;
28358 }
28359
28360
28361 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28362 PyObject *resultobj = 0;
28363 wxPyApp *arg1 = (wxPyApp *) 0 ;
28364 void *argp1 = 0 ;
28365 int res1 = 0 ;
28366 PyObject *swig_obj[1] ;
28367
28368 if (!args) SWIG_fail;
28369 swig_obj[0] = args;
28370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28371 if (!SWIG_IsOK(res1)) {
28372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28373 }
28374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 (arg1)->_BootstrapApp();
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 resultobj = SWIG_Py_Void();
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *resultobj = 0;
28390 int result;
28391
28392 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (int)wxPyApp_GetComCtl32Version();
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_From_int(static_cast< int >(result));
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *obj;
28408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28410 return SWIG_Py_Void();
28411 }
28412
28413 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 return SWIG_Python_InitShadowInstance(args);
28415 }
28416
28417 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419
28420 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 wxExit();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 resultobj = SWIG_Py_Void();
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28435 PyObject *resultobj = 0;
28436 bool result;
28437
28438 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (bool)wxYield();
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 {
28446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28447 }
28448 return resultobj;
28449 fail:
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 PyObject *resultobj = 0;
28456 bool result;
28457
28458 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (bool)wxYieldIfNeeded();
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_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj = 0;
28476 wxWindow *arg1 = (wxWindow *) NULL ;
28477 bool arg2 = (bool) false ;
28478 bool result;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 bool val2 ;
28482 int ecode2 = 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char * kwnames[] = {
28486 (char *) "win",(char *) "onlyIfNeeded", NULL
28487 };
28488
28489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28490 if (obj0) {
28491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28494 }
28495 arg1 = reinterpret_cast< wxWindow * >(argp1);
28496 }
28497 if (obj1) {
28498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28499 if (!SWIG_IsOK(ecode2)) {
28500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28501 }
28502 arg2 = static_cast< bool >(val2);
28503 }
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (bool)wxSafeYield(arg1,arg2);
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *resultobj = 0;
28521
28522 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28523 {
28524 PyThreadState* __tstate = wxPyBeginAllowThreads();
28525 wxWakeUpIdle();
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 resultobj = SWIG_Py_Void();
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj = 0;
28538 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28539 wxEvent *arg2 = 0 ;
28540 void *argp1 = 0 ;
28541 int res1 = 0 ;
28542 void *argp2 = 0 ;
28543 int res2 = 0 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char * kwnames[] = {
28547 (char *) "dest",(char *) "event", NULL
28548 };
28549
28550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28554 }
28555 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28557 if (!SWIG_IsOK(res2)) {
28558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28559 }
28560 if (!argp2) {
28561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28562 }
28563 arg2 = reinterpret_cast< wxEvent * >(argp2);
28564 {
28565 PyThreadState* __tstate = wxPyBeginAllowThreads();
28566 wxPostEvent(arg1,*arg2);
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 resultobj = SWIG_Py_Void();
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28578 PyObject *resultobj = 0;
28579
28580 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 wxApp_CleanUp();
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 resultobj = SWIG_Py_Void();
28588 return resultobj;
28589 fail:
28590 return NULL;
28591 }
28592
28593
28594 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28595 PyObject *resultobj = 0;
28596 wxPyApp *result = 0 ;
28597
28598 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (wxPyApp *)wxPyGetApp();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = wxPyMake_wxObject(result, 0);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 char *arg1 = (char *) 0 ;
28617 int res1 ;
28618 char *buf1 = 0 ;
28619 int alloc1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "encoding", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28626 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28629 }
28630 arg1 = buf1;
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 wxSetDefaultPyEncoding((char const *)arg1);
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_Py_Void();
28638 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28639 return resultobj;
28640 fail:
28641 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648 char *result = 0 ;
28649
28650 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (char *)wxGetDefaultPyEncoding();
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 resultobj = SWIG_FromCharPtr(result);
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 PyObject *resultobj = 0;
28666 wxEventLoop *result = 0 ;
28667
28668 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (wxEventLoop *)new wxEventLoop();
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28683 PyObject *resultobj = 0;
28684 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28685 void *argp1 = 0 ;
28686 int res1 = 0 ;
28687 PyObject *swig_obj[1] ;
28688
28689 if (!args) SWIG_fail;
28690 swig_obj[0] = args;
28691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28692 if (!SWIG_IsOK(res1)) {
28693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28694 }
28695 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 delete arg1;
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 resultobj = SWIG_Py_Void();
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28711 PyObject *resultobj = 0;
28712 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28713 int result;
28714 void *argp1 = 0 ;
28715 int res1 = 0 ;
28716 PyObject *swig_obj[1] ;
28717
28718 if (!args) SWIG_fail;
28719 swig_obj[0] = args;
28720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28721 if (!SWIG_IsOK(res1)) {
28722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28723 }
28724 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = (int)(arg1)->Run();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_From_int(static_cast< int >(result));
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj = 0;
28740 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28741 int arg2 = (int) 0 ;
28742 void *argp1 = 0 ;
28743 int res1 = 0 ;
28744 int val2 ;
28745 int ecode2 = 0 ;
28746 PyObject * obj0 = 0 ;
28747 PyObject * obj1 = 0 ;
28748 char * kwnames[] = {
28749 (char *) "self",(char *) "rc", NULL
28750 };
28751
28752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28756 }
28757 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28758 if (obj1) {
28759 ecode2 = SWIG_AsVal_int(obj1, &val2);
28760 if (!SWIG_IsOK(ecode2)) {
28761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28762 }
28763 arg2 = static_cast< int >(val2);
28764 }
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 (arg1)->Exit(arg2);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_Py_Void();
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28781 bool result;
28782 void *argp1 = 0 ;
28783 int res1 = 0 ;
28784 PyObject *swig_obj[1] ;
28785
28786 if (!args) SWIG_fail;
28787 swig_obj[0] = args;
28788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28791 }
28792 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = (bool)((wxEventLoop const *)arg1)->Pending();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 {
28800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28801 }
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28809 PyObject *resultobj = 0;
28810 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28811 bool result;
28812 void *argp1 = 0 ;
28813 int res1 = 0 ;
28814 PyObject *swig_obj[1] ;
28815
28816 if (!args) SWIG_fail;
28817 swig_obj[0] = args;
28818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28819 if (!SWIG_IsOK(res1)) {
28820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28821 }
28822 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = (bool)(arg1)->Dispatch();
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 {
28830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28831 }
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28839 PyObject *resultobj = 0;
28840 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28841 bool result;
28842 void *argp1 = 0 ;
28843 int res1 = 0 ;
28844 PyObject *swig_obj[1] ;
28845
28846 if (!args) SWIG_fail;
28847 swig_obj[0] = args;
28848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28849 if (!SWIG_IsOK(res1)) {
28850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28851 }
28852 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 {
28860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28861 }
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28869 PyObject *resultobj = 0;
28870 wxEventLoop *result = 0 ;
28871
28872 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (wxEventLoop *)wxEventLoop::GetActive();
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj = 0;
28888 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28889 void *argp1 = 0 ;
28890 int res1 = 0 ;
28891 PyObject * obj0 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "loop", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28898 if (!SWIG_IsOK(res1)) {
28899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28900 }
28901 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 wxEventLoop::SetActive(arg1);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_Py_Void();
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28916 PyObject *obj;
28917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28918 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28919 return SWIG_Py_Void();
28920 }
28921
28922 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28923 return SWIG_Python_InitShadowInstance(args);
28924 }
28925
28926 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj = 0;
28928 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28929 wxEventLoopActivator *result = 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject * obj0 = 0 ;
28933 char * kwnames[] = {
28934 (char *) "evtLoop", NULL
28935 };
28936
28937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28941 }
28942 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28950 return resultobj;
28951 fail:
28952 return NULL;
28953 }
28954
28955
28956 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28957 PyObject *resultobj = 0;
28958 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28968 }
28969 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 delete arg1;
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 resultobj = SWIG_Py_Void();
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28985 PyObject *obj;
28986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28987 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28988 return SWIG_Py_Void();
28989 }
28990
28991 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28992 return SWIG_Python_InitShadowInstance(args);
28993 }
28994
28995 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj = 0;
28997 int arg1 = (int) 0 ;
28998 int arg2 = (int) 0 ;
28999 int arg3 = (int) 0 ;
29000 wxAcceleratorEntry *result = 0 ;
29001 int val1 ;
29002 int ecode1 = 0 ;
29003 int val2 ;
29004 int ecode2 = 0 ;
29005 int val3 ;
29006 int ecode3 = 0 ;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 PyObject * obj2 = 0 ;
29010 char * kwnames[] = {
29011 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29012 };
29013
29014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29015 if (obj0) {
29016 ecode1 = SWIG_AsVal_int(obj0, &val1);
29017 if (!SWIG_IsOK(ecode1)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29019 }
29020 arg1 = static_cast< int >(val1);
29021 }
29022 if (obj1) {
29023 ecode2 = SWIG_AsVal_int(obj1, &val2);
29024 if (!SWIG_IsOK(ecode2)) {
29025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29026 }
29027 arg2 = static_cast< int >(val2);
29028 }
29029 if (obj2) {
29030 ecode3 = SWIG_AsVal_int(obj2, &val3);
29031 if (!SWIG_IsOK(ecode3)) {
29032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29033 }
29034 arg3 = static_cast< int >(val3);
29035 }
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29043 return resultobj;
29044 fail:
29045 return NULL;
29046 }
29047
29048
29049 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 PyObject *resultobj = 0;
29051 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29052 void *argp1 = 0 ;
29053 int res1 = 0 ;
29054 PyObject *swig_obj[1] ;
29055
29056 if (!args) SWIG_fail;
29057 swig_obj[0] = args;
29058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29059 if (!SWIG_IsOK(res1)) {
29060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29061 }
29062 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 delete arg1;
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_Py_Void();
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29080 int arg2 ;
29081 int arg3 ;
29082 int arg4 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 int val2 ;
29086 int ecode2 = 0 ;
29087 int val3 ;
29088 int ecode3 = 0 ;
29089 int val4 ;
29090 int ecode4 = 0 ;
29091 PyObject * obj0 = 0 ;
29092 PyObject * obj1 = 0 ;
29093 PyObject * obj2 = 0 ;
29094 PyObject * obj3 = 0 ;
29095 char * kwnames[] = {
29096 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29097 };
29098
29099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29101 if (!SWIG_IsOK(res1)) {
29102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29103 }
29104 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29105 ecode2 = SWIG_AsVal_int(obj1, &val2);
29106 if (!SWIG_IsOK(ecode2)) {
29107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29108 }
29109 arg2 = static_cast< int >(val2);
29110 ecode3 = SWIG_AsVal_int(obj2, &val3);
29111 if (!SWIG_IsOK(ecode3)) {
29112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29113 }
29114 arg3 = static_cast< int >(val3);
29115 ecode4 = SWIG_AsVal_int(obj3, &val4);
29116 if (!SWIG_IsOK(ecode4)) {
29117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29118 }
29119 arg4 = static_cast< int >(val4);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 (arg1)->Set(arg2,arg3,arg4);
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_Py_Void();
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29136 int result;
29137 void *argp1 = 0 ;
29138 int res1 = 0 ;
29139 PyObject *swig_obj[1] ;
29140
29141 if (!args) SWIG_fail;
29142 swig_obj[0] = args;
29143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29144 if (!SWIG_IsOK(res1)) {
29145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29146 }
29147 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 result = (int)(arg1)->GetFlags();
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_From_int(static_cast< int >(result));
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29162 PyObject *resultobj = 0;
29163 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29164 int result;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 PyObject *swig_obj[1] ;
29168
29169 if (!args) SWIG_fail;
29170 swig_obj[0] = args;
29171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29172 if (!SWIG_IsOK(res1)) {
29173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29174 }
29175 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 result = (int)(arg1)->GetKeyCode();
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 resultobj = SWIG_From_int(static_cast< int >(result));
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29190 PyObject *resultobj = 0;
29191 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29192 int result;
29193 void *argp1 = 0 ;
29194 int res1 = 0 ;
29195 PyObject *swig_obj[1] ;
29196
29197 if (!args) SWIG_fail;
29198 swig_obj[0] = args;
29199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29200 if (!SWIG_IsOK(res1)) {
29201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29202 }
29203 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (int)(arg1)->GetCommand();
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 resultobj = SWIG_From_int(static_cast< int >(result));
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29218 PyObject *obj;
29219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29220 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29221 return SWIG_Py_Void();
29222 }
29223
29224 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29225 return SWIG_Python_InitShadowInstance(args);
29226 }
29227
29228 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj = 0;
29230 int arg1 ;
29231 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29232 wxAcceleratorTable *result = 0 ;
29233 PyObject * obj0 = 0 ;
29234 char * kwnames[] = {
29235 (char *) "n", NULL
29236 };
29237
29238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29239 {
29240 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29241 if (arg2) arg1 = PyList_Size(obj0);
29242 else arg1 = 0;
29243 }
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29258 PyObject *resultobj = 0;
29259 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29260 void *argp1 = 0 ;
29261 int res1 = 0 ;
29262 PyObject *swig_obj[1] ;
29263
29264 if (!args) SWIG_fail;
29265 swig_obj[0] = args;
29266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29267 if (!SWIG_IsOK(res1)) {
29268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29269 }
29270 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 delete arg1;
29274
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_Py_Void();
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29286 PyObject *resultobj = 0;
29287 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29288 bool result;
29289 void *argp1 = 0 ;
29290 int res1 = 0 ;
29291 PyObject *swig_obj[1] ;
29292
29293 if (!args) SWIG_fail;
29294 swig_obj[0] = args;
29295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29298 }
29299 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 {
29307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29308 }
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *obj;
29317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29318 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29319 return SWIG_Py_Void();
29320 }
29321
29322 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29323 return SWIG_Python_InitShadowInstance(args);
29324 }
29325
29326 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29327 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29328 return 1;
29329 }
29330
29331
29332 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29333 PyObject *pyobj = 0;
29334
29335 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29336 return pyobj;
29337 }
29338
29339
29340 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj = 0;
29342 wxString *arg1 = 0 ;
29343 wxAcceleratorEntry *result = 0 ;
29344 bool temp1 = false ;
29345 PyObject * obj0 = 0 ;
29346 char * kwnames[] = {
29347 (char *) "label", NULL
29348 };
29349
29350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29351 {
29352 arg1 = wxString_in_helper(obj0);
29353 if (arg1 == NULL) SWIG_fail;
29354 temp1 = true;
29355 }
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29363 {
29364 if (temp1)
29365 delete arg1;
29366 }
29367 return resultobj;
29368 fail:
29369 {
29370 if (temp1)
29371 delete arg1;
29372 }
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN int PanelNameStr_set(PyObject *) {
29378 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29379 return 1;
29380 }
29381
29382
29383 SWIGINTERN PyObject *PanelNameStr_get(void) {
29384 PyObject *pyobj = 0;
29385
29386 {
29387 #if wxUSE_UNICODE
29388 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29389 #else
29390 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29391 #endif
29392 }
29393 return pyobj;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29398 PyObject *resultobj = 0;
29399 wxVisualAttributes *result = 0 ;
29400
29401 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 result = (wxVisualAttributes *)new_wxVisualAttributes();
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29427 }
29428 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 delete_wxVisualAttributes(arg1);
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_Py_Void();
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29446 wxFont *arg2 = (wxFont *) 0 ;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 void *argp2 = 0 ;
29450 int res2 = 0 ;
29451 PyObject *swig_obj[2] ;
29452
29453 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29457 }
29458 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29459 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29460 if (!SWIG_IsOK(res2)) {
29461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29462 }
29463 arg2 = reinterpret_cast< wxFont * >(argp2);
29464 if (arg1) (arg1)->font = *arg2;
29465
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29476 wxFont *result = 0 ;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 PyObject *swig_obj[1] ;
29480
29481 if (!args) SWIG_fail;
29482 swig_obj[0] = args;
29483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29486 }
29487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29488 result = (wxFont *)& ((arg1)->font);
29489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *resultobj = 0;
29498 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29499 wxColour *arg2 = (wxColour *) 0 ;
29500 void *argp1 = 0 ;
29501 int res1 = 0 ;
29502 void *argp2 = 0 ;
29503 int res2 = 0 ;
29504 PyObject *swig_obj[2] ;
29505
29506 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29508 if (!SWIG_IsOK(res1)) {
29509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29510 }
29511 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29512 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29513 if (!SWIG_IsOK(res2)) {
29514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29515 }
29516 arg2 = reinterpret_cast< wxColour * >(argp2);
29517 if (arg1) (arg1)->colFg = *arg2;
29518
29519 resultobj = SWIG_Py_Void();
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29527 PyObject *resultobj = 0;
29528 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29529 wxColour *result = 0 ;
29530 void *argp1 = 0 ;
29531 int res1 = 0 ;
29532 PyObject *swig_obj[1] ;
29533
29534 if (!args) SWIG_fail;
29535 swig_obj[0] = args;
29536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29537 if (!SWIG_IsOK(res1)) {
29538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29539 }
29540 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29541 result = (wxColour *)& ((arg1)->colFg);
29542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29543 return resultobj;
29544 fail:
29545 return NULL;
29546 }
29547
29548
29549 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29550 PyObject *resultobj = 0;
29551 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29552 wxColour *arg2 = (wxColour *) 0 ;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 void *argp2 = 0 ;
29556 int res2 = 0 ;
29557 PyObject *swig_obj[2] ;
29558
29559 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29561 if (!SWIG_IsOK(res1)) {
29562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29563 }
29564 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29565 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29566 if (!SWIG_IsOK(res2)) {
29567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29568 }
29569 arg2 = reinterpret_cast< wxColour * >(argp2);
29570 if (arg1) (arg1)->colBg = *arg2;
29571
29572 resultobj = SWIG_Py_Void();
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *resultobj = 0;
29581 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29582 wxColour *result = 0 ;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 PyObject *swig_obj[1] ;
29586
29587 if (!args) SWIG_fail;
29588 swig_obj[0] = args;
29589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29590 if (!SWIG_IsOK(res1)) {
29591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29592 }
29593 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29594 result = (wxColour *)& ((arg1)->colBg);
29595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603 PyObject *obj;
29604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29605 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29606 return SWIG_Py_Void();
29607 }
29608
29609 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29610 return SWIG_Python_InitShadowInstance(args);
29611 }
29612
29613 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29614 PyObject *resultobj = 0;
29615 wxWindow *arg1 = (wxWindow *) 0 ;
29616 int arg2 = (int) (int)-1 ;
29617 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29618 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29619 wxSize const &arg4_defvalue = wxDefaultSize ;
29620 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29621 long arg5 = (long) 0 ;
29622 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29623 wxString *arg6 = (wxString *) &arg6_defvalue ;
29624 wxWindow *result = 0 ;
29625 void *argp1 = 0 ;
29626 int res1 = 0 ;
29627 int val2 ;
29628 int ecode2 = 0 ;
29629 wxPoint temp3 ;
29630 wxSize temp4 ;
29631 long val5 ;
29632 int ecode5 = 0 ;
29633 bool temp6 = false ;
29634 PyObject * obj0 = 0 ;
29635 PyObject * obj1 = 0 ;
29636 PyObject * obj2 = 0 ;
29637 PyObject * obj3 = 0 ;
29638 PyObject * obj4 = 0 ;
29639 PyObject * obj5 = 0 ;
29640 char * kwnames[] = {
29641 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29642 };
29643
29644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29648 }
29649 arg1 = reinterpret_cast< wxWindow * >(argp1);
29650 if (obj1) {
29651 ecode2 = SWIG_AsVal_int(obj1, &val2);
29652 if (!SWIG_IsOK(ecode2)) {
29653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29654 }
29655 arg2 = static_cast< int >(val2);
29656 }
29657 if (obj2) {
29658 {
29659 arg3 = &temp3;
29660 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29661 }
29662 }
29663 if (obj3) {
29664 {
29665 arg4 = &temp4;
29666 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29667 }
29668 }
29669 if (obj4) {
29670 ecode5 = SWIG_AsVal_long(obj4, &val5);
29671 if (!SWIG_IsOK(ecode5)) {
29672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29673 }
29674 arg5 = static_cast< long >(val5);
29675 }
29676 if (obj5) {
29677 {
29678 arg6 = wxString_in_helper(obj5);
29679 if (arg6 == NULL) SWIG_fail;
29680 temp6 = true;
29681 }
29682 }
29683 {
29684 if (!wxPyCheckForApp()) SWIG_fail;
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29691 {
29692 if (temp6)
29693 delete arg6;
29694 }
29695 return resultobj;
29696 fail:
29697 {
29698 if (temp6)
29699 delete arg6;
29700 }
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxWindow *result = 0 ;
29708
29709 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29710 {
29711 if (!wxPyCheckForApp()) SWIG_fail;
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = (wxWindow *)new wxWindow();
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj = 0;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 wxWindow *arg2 = (wxWindow *) 0 ;
29728 int arg3 = (int) (int)-1 ;
29729 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29730 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29731 wxSize const &arg5_defvalue = wxDefaultSize ;
29732 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29733 long arg6 = (long) 0 ;
29734 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29735 wxString *arg7 = (wxString *) &arg7_defvalue ;
29736 bool result;
29737 void *argp1 = 0 ;
29738 int res1 = 0 ;
29739 void *argp2 = 0 ;
29740 int res2 = 0 ;
29741 int val3 ;
29742 int ecode3 = 0 ;
29743 wxPoint temp4 ;
29744 wxSize temp5 ;
29745 long val6 ;
29746 int ecode6 = 0 ;
29747 bool temp7 = false ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 PyObject * obj2 = 0 ;
29751 PyObject * obj3 = 0 ;
29752 PyObject * obj4 = 0 ;
29753 PyObject * obj5 = 0 ;
29754 PyObject * obj6 = 0 ;
29755 char * kwnames[] = {
29756 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29757 };
29758
29759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29761 if (!SWIG_IsOK(res1)) {
29762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29763 }
29764 arg1 = reinterpret_cast< wxWindow * >(argp1);
29765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29766 if (!SWIG_IsOK(res2)) {
29767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29768 }
29769 arg2 = reinterpret_cast< wxWindow * >(argp2);
29770 if (obj2) {
29771 ecode3 = SWIG_AsVal_int(obj2, &val3);
29772 if (!SWIG_IsOK(ecode3)) {
29773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29774 }
29775 arg3 = static_cast< int >(val3);
29776 }
29777 if (obj3) {
29778 {
29779 arg4 = &temp4;
29780 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29781 }
29782 }
29783 if (obj4) {
29784 {
29785 arg5 = &temp5;
29786 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29787 }
29788 }
29789 if (obj5) {
29790 ecode6 = SWIG_AsVal_long(obj5, &val6);
29791 if (!SWIG_IsOK(ecode6)) {
29792 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29793 }
29794 arg6 = static_cast< long >(val6);
29795 }
29796 if (obj6) {
29797 {
29798 arg7 = wxString_in_helper(obj6);
29799 if (arg7 == NULL) SWIG_fail;
29800 temp7 = true;
29801 }
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 {
29810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29811 }
29812 {
29813 if (temp7)
29814 delete arg7;
29815 }
29816 return resultobj;
29817 fail:
29818 {
29819 if (temp7)
29820 delete arg7;
29821 }
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 bool arg2 = (bool) false ;
29830 bool result;
29831 void *argp1 = 0 ;
29832 int res1 = 0 ;
29833 bool val2 ;
29834 int ecode2 = 0 ;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 char * kwnames[] = {
29838 (char *) "self",(char *) "force", NULL
29839 };
29840
29841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29843 if (!SWIG_IsOK(res1)) {
29844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29845 }
29846 arg1 = reinterpret_cast< wxWindow * >(argp1);
29847 if (obj1) {
29848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29849 if (!SWIG_IsOK(ecode2)) {
29850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29851 }
29852 arg2 = static_cast< bool >(val2);
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (bool)(arg1)->Close(arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 {
29861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 bool result;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 PyObject *swig_obj[1] ;
29876
29877 if (!args) SWIG_fail;
29878 swig_obj[0] = args;
29879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29882 }
29883 arg1 = reinterpret_cast< wxWindow * >(argp1);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (bool)(arg1)->Destroy();
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 {
29891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29892 }
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29900 PyObject *resultobj = 0;
29901 wxWindow *arg1 = (wxWindow *) 0 ;
29902 bool result;
29903 void *argp1 = 0 ;
29904 int res1 = 0 ;
29905 PyObject *swig_obj[1] ;
29906
29907 if (!args) SWIG_fail;
29908 swig_obj[0] = args;
29909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29910 if (!SWIG_IsOK(res1)) {
29911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29912 }
29913 arg1 = reinterpret_cast< wxWindow * >(argp1);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)(arg1)->DestroyChildren();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 {
29921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29922 }
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29930 PyObject *resultobj = 0;
29931 wxWindow *arg1 = (wxWindow *) 0 ;
29932 bool result;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 PyObject *swig_obj[1] ;
29936
29937 if (!args) SWIG_fail;
29938 swig_obj[0] = args;
29939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29942 }
29943 arg1 = reinterpret_cast< wxWindow * >(argp1);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj = 0;
29961 wxWindow *arg1 = (wxWindow *) 0 ;
29962 wxString *arg2 = 0 ;
29963 void *argp1 = 0 ;
29964 int res1 = 0 ;
29965 bool temp2 = false ;
29966 PyObject * obj0 = 0 ;
29967 PyObject * obj1 = 0 ;
29968 char * kwnames[] = {
29969 (char *) "self",(char *) "label", NULL
29970 };
29971
29972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29976 }
29977 arg1 = reinterpret_cast< wxWindow * >(argp1);
29978 {
29979 arg2 = wxString_in_helper(obj1);
29980 if (arg2 == NULL) SWIG_fail;
29981 temp2 = true;
29982 }
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 (arg1)->SetLabel((wxString const &)*arg2);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_Py_Void();
29990 {
29991 if (temp2)
29992 delete arg2;
29993 }
29994 return resultobj;
29995 fail:
29996 {
29997 if (temp2)
29998 delete arg2;
29999 }
30000 return NULL;
30001 }
30002
30003
30004 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30005 PyObject *resultobj = 0;
30006 wxWindow *arg1 = (wxWindow *) 0 ;
30007 wxString result;
30008 void *argp1 = 0 ;
30009 int res1 = 0 ;
30010 PyObject *swig_obj[1] ;
30011
30012 if (!args) SWIG_fail;
30013 swig_obj[0] = args;
30014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30015 if (!SWIG_IsOK(res1)) {
30016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30017 }
30018 arg1 = reinterpret_cast< wxWindow * >(argp1);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = ((wxWindow const *)arg1)->GetLabel();
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 {
30026 #if wxUSE_UNICODE
30027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30028 #else
30029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30030 #endif
30031 }
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 wxWindow *arg1 = (wxWindow *) 0 ;
30041 wxString *arg2 = 0 ;
30042 void *argp1 = 0 ;
30043 int res1 = 0 ;
30044 bool temp2 = false ;
30045 PyObject * obj0 = 0 ;
30046 PyObject * obj1 = 0 ;
30047 char * kwnames[] = {
30048 (char *) "self",(char *) "name", NULL
30049 };
30050
30051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30055 }
30056 arg1 = reinterpret_cast< wxWindow * >(argp1);
30057 {
30058 arg2 = wxString_in_helper(obj1);
30059 if (arg2 == NULL) SWIG_fail;
30060 temp2 = true;
30061 }
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 (arg1)->SetName((wxString const &)*arg2);
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_Py_Void();
30069 {
30070 if (temp2)
30071 delete arg2;
30072 }
30073 return resultobj;
30074 fail:
30075 {
30076 if (temp2)
30077 delete arg2;
30078 }
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30084 PyObject *resultobj = 0;
30085 wxWindow *arg1 = (wxWindow *) 0 ;
30086 wxString result;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 PyObject *swig_obj[1] ;
30090
30091 if (!args) SWIG_fail;
30092 swig_obj[0] = args;
30093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30096 }
30097 arg1 = reinterpret_cast< wxWindow * >(argp1);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = ((wxWindow const *)arg1)->GetName();
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 {
30105 #if wxUSE_UNICODE
30106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30107 #else
30108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30109 #endif
30110 }
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj = 0;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 wxWindowVariant arg2 ;
30121 void *argp1 = 0 ;
30122 int res1 = 0 ;
30123 int val2 ;
30124 int ecode2 = 0 ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char * kwnames[] = {
30128 (char *) "self",(char *) "variant", NULL
30129 };
30130
30131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30133 if (!SWIG_IsOK(res1)) {
30134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30135 }
30136 arg1 = reinterpret_cast< wxWindow * >(argp1);
30137 ecode2 = SWIG_AsVal_int(obj1, &val2);
30138 if (!SWIG_IsOK(ecode2)) {
30139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30140 }
30141 arg2 = static_cast< wxWindowVariant >(val2);
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetWindowVariant(arg2);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30156 PyObject *resultobj = 0;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 wxWindowVariant result;
30159 void *argp1 = 0 ;
30160 int res1 = 0 ;
30161 PyObject *swig_obj[1] ;
30162
30163 if (!args) SWIG_fail;
30164 swig_obj[0] = args;
30165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30168 }
30169 arg1 = reinterpret_cast< wxWindow * >(argp1);
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 resultobj = SWIG_From_int(static_cast< int >(result));
30177 return resultobj;
30178 fail:
30179 return NULL;
30180 }
30181
30182
30183 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30184 PyObject *resultobj = 0;
30185 wxWindow *arg1 = (wxWindow *) 0 ;
30186 int arg2 ;
30187 void *argp1 = 0 ;
30188 int res1 = 0 ;
30189 int val2 ;
30190 int ecode2 = 0 ;
30191 PyObject * obj0 = 0 ;
30192 PyObject * obj1 = 0 ;
30193 char * kwnames[] = {
30194 (char *) "self",(char *) "winid", NULL
30195 };
30196
30197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30199 if (!SWIG_IsOK(res1)) {
30200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30201 }
30202 arg1 = reinterpret_cast< wxWindow * >(argp1);
30203 ecode2 = SWIG_AsVal_int(obj1, &val2);
30204 if (!SWIG_IsOK(ecode2)) {
30205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30206 }
30207 arg2 = static_cast< int >(val2);
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 (arg1)->SetId(arg2);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_Py_Void();
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 int result;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 PyObject *swig_obj[1] ;
30228
30229 if (!args) SWIG_fail;
30230 swig_obj[0] = args;
30231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30232 if (!SWIG_IsOK(res1)) {
30233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30234 }
30235 arg1 = reinterpret_cast< wxWindow * >(argp1);
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 result = (int)((wxWindow const *)arg1)->GetId();
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_From_int(static_cast< int >(result));
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30250 PyObject *resultobj = 0;
30251 int result;
30252
30253 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (int)wxWindow::NewControlId();
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 resultobj = SWIG_From_int(static_cast< int >(result));
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj = 0;
30269 int arg1 ;
30270 int result;
30271 int val1 ;
30272 int ecode1 = 0 ;
30273 PyObject * obj0 = 0 ;
30274 char * kwnames[] = {
30275 (char *) "winid", NULL
30276 };
30277
30278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30279 ecode1 = SWIG_AsVal_int(obj0, &val1);
30280 if (!SWIG_IsOK(ecode1)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30282 }
30283 arg1 = static_cast< int >(val1);
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 result = (int)wxWindow::NextControlId(arg1);
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 resultobj = SWIG_From_int(static_cast< int >(result));
30291 return resultobj;
30292 fail:
30293 return NULL;
30294 }
30295
30296
30297 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30298 PyObject *resultobj = 0;
30299 int arg1 ;
30300 int result;
30301 int val1 ;
30302 int ecode1 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 char * kwnames[] = {
30305 (char *) "winid", NULL
30306 };
30307
30308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30309 ecode1 = SWIG_AsVal_int(obj0, &val1);
30310 if (!SWIG_IsOK(ecode1)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30312 }
30313 arg1 = static_cast< int >(val1);
30314 {
30315 PyThreadState* __tstate = wxPyBeginAllowThreads();
30316 result = (int)wxWindow::PrevControlId(arg1);
30317 wxPyEndAllowThreads(__tstate);
30318 if (PyErr_Occurred()) SWIG_fail;
30319 }
30320 resultobj = SWIG_From_int(static_cast< int >(result));
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30328 PyObject *resultobj = 0;
30329 wxWindow *arg1 = (wxWindow *) 0 ;
30330 wxSize *arg2 = 0 ;
30331 void *argp1 = 0 ;
30332 int res1 = 0 ;
30333 wxSize temp2 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char * kwnames[] = {
30337 (char *) "self",(char *) "size", NULL
30338 };
30339
30340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30342 if (!SWIG_IsOK(res1)) {
30343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30344 }
30345 arg1 = reinterpret_cast< wxWindow * >(argp1);
30346 {
30347 arg2 = &temp2;
30348 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->SetSize((wxSize const &)*arg2);
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 resultobj = SWIG_Py_Void();
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30364 PyObject *resultobj = 0;
30365 wxWindow *arg1 = (wxWindow *) 0 ;
30366 int arg2 ;
30367 int arg3 ;
30368 int arg4 ;
30369 int arg5 ;
30370 int arg6 = (int) wxSIZE_AUTO ;
30371 void *argp1 = 0 ;
30372 int res1 = 0 ;
30373 int val2 ;
30374 int ecode2 = 0 ;
30375 int val3 ;
30376 int ecode3 = 0 ;
30377 int val4 ;
30378 int ecode4 = 0 ;
30379 int val5 ;
30380 int ecode5 = 0 ;
30381 int val6 ;
30382 int ecode6 = 0 ;
30383 PyObject * obj0 = 0 ;
30384 PyObject * obj1 = 0 ;
30385 PyObject * obj2 = 0 ;
30386 PyObject * obj3 = 0 ;
30387 PyObject * obj4 = 0 ;
30388 PyObject * obj5 = 0 ;
30389 char * kwnames[] = {
30390 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30391 };
30392
30393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30397 }
30398 arg1 = reinterpret_cast< wxWindow * >(argp1);
30399 ecode2 = SWIG_AsVal_int(obj1, &val2);
30400 if (!SWIG_IsOK(ecode2)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30402 }
30403 arg2 = static_cast< int >(val2);
30404 ecode3 = SWIG_AsVal_int(obj2, &val3);
30405 if (!SWIG_IsOK(ecode3)) {
30406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30407 }
30408 arg3 = static_cast< int >(val3);
30409 ecode4 = SWIG_AsVal_int(obj3, &val4);
30410 if (!SWIG_IsOK(ecode4)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30412 }
30413 arg4 = static_cast< int >(val4);
30414 ecode5 = SWIG_AsVal_int(obj4, &val5);
30415 if (!SWIG_IsOK(ecode5)) {
30416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30417 }
30418 arg5 = static_cast< int >(val5);
30419 if (obj5) {
30420 ecode6 = SWIG_AsVal_int(obj5, &val6);
30421 if (!SWIG_IsOK(ecode6)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30423 }
30424 arg6 = static_cast< int >(val6);
30425 }
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj = 0;
30441 wxWindow *arg1 = (wxWindow *) 0 ;
30442 wxRect *arg2 = 0 ;
30443 int arg3 = (int) wxSIZE_AUTO ;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 wxRect temp2 ;
30447 int val3 ;
30448 int ecode3 = 0 ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 char * kwnames[] = {
30453 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30454 };
30455
30456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30458 if (!SWIG_IsOK(res1)) {
30459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30460 }
30461 arg1 = reinterpret_cast< wxWindow * >(argp1);
30462 {
30463 arg2 = &temp2;
30464 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30465 }
30466 if (obj2) {
30467 ecode3 = SWIG_AsVal_int(obj2, &val3);
30468 if (!SWIG_IsOK(ecode3)) {
30469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30470 }
30471 arg3 = static_cast< int >(val3);
30472 }
30473 {
30474 PyThreadState* __tstate = wxPyBeginAllowThreads();
30475 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_Py_Void();
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxWindow *arg1 = (wxWindow *) 0 ;
30489 int arg2 ;
30490 int arg3 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 int val2 ;
30494 int ecode2 = 0 ;
30495 int val3 ;
30496 int ecode3 = 0 ;
30497 PyObject * obj0 = 0 ;
30498 PyObject * obj1 = 0 ;
30499 PyObject * obj2 = 0 ;
30500 char * kwnames[] = {
30501 (char *) "self",(char *) "width",(char *) "height", NULL
30502 };
30503
30504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30508 }
30509 arg1 = reinterpret_cast< wxWindow * >(argp1);
30510 ecode2 = SWIG_AsVal_int(obj1, &val2);
30511 if (!SWIG_IsOK(ecode2)) {
30512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30513 }
30514 arg2 = static_cast< int >(val2);
30515 ecode3 = SWIG_AsVal_int(obj2, &val3);
30516 if (!SWIG_IsOK(ecode3)) {
30517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30518 }
30519 arg3 = static_cast< int >(val3);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetSize(arg2,arg3);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30534 PyObject *resultobj = 0;
30535 wxWindow *arg1 = (wxWindow *) 0 ;
30536 wxPoint *arg2 = 0 ;
30537 int arg3 = (int) wxSIZE_USE_EXISTING ;
30538 void *argp1 = 0 ;
30539 int res1 = 0 ;
30540 wxPoint temp2 ;
30541 int val3 ;
30542 int ecode3 = 0 ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 PyObject * obj2 = 0 ;
30546 char * kwnames[] = {
30547 (char *) "self",(char *) "pt",(char *) "flags", NULL
30548 };
30549
30550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30552 if (!SWIG_IsOK(res1)) {
30553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30554 }
30555 arg1 = reinterpret_cast< wxWindow * >(argp1);
30556 {
30557 arg2 = &temp2;
30558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30559 }
30560 if (obj2) {
30561 ecode3 = SWIG_AsVal_int(obj2, &val3);
30562 if (!SWIG_IsOK(ecode3)) {
30563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30564 }
30565 arg3 = static_cast< int >(val3);
30566 }
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 (arg1)->Move((wxPoint const &)*arg2,arg3);
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_Py_Void();
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj = 0;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 int arg2 ;
30584 int arg3 ;
30585 int arg4 = (int) wxSIZE_USE_EXISTING ;
30586 void *argp1 = 0 ;
30587 int res1 = 0 ;
30588 int val2 ;
30589 int ecode2 = 0 ;
30590 int val3 ;
30591 int ecode3 = 0 ;
30592 int val4 ;
30593 int ecode4 = 0 ;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 PyObject * obj2 = 0 ;
30597 PyObject * obj3 = 0 ;
30598 char * kwnames[] = {
30599 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30600 };
30601
30602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30604 if (!SWIG_IsOK(res1)) {
30605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30606 }
30607 arg1 = reinterpret_cast< wxWindow * >(argp1);
30608 ecode2 = SWIG_AsVal_int(obj1, &val2);
30609 if (!SWIG_IsOK(ecode2)) {
30610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30611 }
30612 arg2 = static_cast< int >(val2);
30613 ecode3 = SWIG_AsVal_int(obj2, &val3);
30614 if (!SWIG_IsOK(ecode3)) {
30615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30616 }
30617 arg3 = static_cast< int >(val3);
30618 if (obj3) {
30619 ecode4 = SWIG_AsVal_int(obj3, &val4);
30620 if (!SWIG_IsOK(ecode4)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30622 }
30623 arg4 = static_cast< int >(val4);
30624 }
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 (arg1)->Move(arg2,arg3,arg4);
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 resultobj = SWIG_Py_Void();
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj = 0;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 wxSize const &arg2_defvalue = wxDefaultSize ;
30642 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 wxSize temp2 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 char * kwnames[] = {
30649 (char *) "self",(char *) "size", NULL
30650 };
30651
30652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30656 }
30657 arg1 = reinterpret_cast< wxWindow * >(argp1);
30658 if (obj1) {
30659 {
30660 arg2 = &temp2;
30661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30662 }
30663 }
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_Py_Void();
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 PyObject *swig_obj[1] ;
30683
30684 if (!args) SWIG_fail;
30685 swig_obj[0] = args;
30686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res1)) {
30688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30689 }
30690 arg1 = reinterpret_cast< wxWindow * >(argp1);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 (arg1)->Raise();
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 void *argp1 = 0 ;
30708 int res1 = 0 ;
30709 PyObject *swig_obj[1] ;
30710
30711 if (!args) SWIG_fail;
30712 swig_obj[0] = args;
30713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30714 if (!SWIG_IsOK(res1)) {
30715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30716 }
30717 arg1 = reinterpret_cast< wxWindow * >(argp1);
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 (arg1)->Lower();
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 resultobj = SWIG_Py_Void();
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30732 PyObject *resultobj = 0;
30733 wxWindow *arg1 = (wxWindow *) 0 ;
30734 wxSize *arg2 = 0 ;
30735 void *argp1 = 0 ;
30736 int res1 = 0 ;
30737 wxSize temp2 ;
30738 PyObject * obj0 = 0 ;
30739 PyObject * obj1 = 0 ;
30740 char * kwnames[] = {
30741 (char *) "self",(char *) "size", NULL
30742 };
30743
30744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 {
30751 arg2 = &temp2;
30752 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30753 }
30754 {
30755 PyThreadState* __tstate = wxPyBeginAllowThreads();
30756 (arg1)->SetClientSize((wxSize const &)*arg2);
30757 wxPyEndAllowThreads(__tstate);
30758 if (PyErr_Occurred()) SWIG_fail;
30759 }
30760 resultobj = SWIG_Py_Void();
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj = 0;
30769 wxWindow *arg1 = (wxWindow *) 0 ;
30770 int arg2 ;
30771 int arg3 ;
30772 void *argp1 = 0 ;
30773 int res1 = 0 ;
30774 int val2 ;
30775 int ecode2 = 0 ;
30776 int val3 ;
30777 int ecode3 = 0 ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 PyObject * obj2 = 0 ;
30781 char * kwnames[] = {
30782 (char *) "self",(char *) "width",(char *) "height", NULL
30783 };
30784
30785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30787 if (!SWIG_IsOK(res1)) {
30788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30789 }
30790 arg1 = reinterpret_cast< wxWindow * >(argp1);
30791 ecode2 = SWIG_AsVal_int(obj1, &val2);
30792 if (!SWIG_IsOK(ecode2)) {
30793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30794 }
30795 arg2 = static_cast< int >(val2);
30796 ecode3 = SWIG_AsVal_int(obj2, &val3);
30797 if (!SWIG_IsOK(ecode3)) {
30798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30799 }
30800 arg3 = static_cast< int >(val3);
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->SetClientSize(arg2,arg3);
30804 wxPyEndAllowThreads(__tstate);
30805 if (PyErr_Occurred()) SWIG_fail;
30806 }
30807 resultobj = SWIG_Py_Void();
30808 return resultobj;
30809 fail:
30810 return NULL;
30811 }
30812
30813
30814 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30815 PyObject *resultobj = 0;
30816 wxWindow *arg1 = (wxWindow *) 0 ;
30817 wxRect *arg2 = 0 ;
30818 void *argp1 = 0 ;
30819 int res1 = 0 ;
30820 wxRect temp2 ;
30821 PyObject * obj0 = 0 ;
30822 PyObject * obj1 = 0 ;
30823 char * kwnames[] = {
30824 (char *) "self",(char *) "rect", NULL
30825 };
30826
30827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30829 if (!SWIG_IsOK(res1)) {
30830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30831 }
30832 arg1 = reinterpret_cast< wxWindow * >(argp1);
30833 {
30834 arg2 = &temp2;
30835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30836 }
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 (arg1)->SetClientSize((wxRect const &)*arg2);
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 resultobj = SWIG_Py_Void();
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 wxPoint 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_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = ((wxWindow const *)arg1)->GetPosition();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30879 PyObject *resultobj = 0;
30880 wxWindow *arg1 = (wxWindow *) 0 ;
30881 int *arg2 = (int *) 0 ;
30882 int *arg3 = (int *) 0 ;
30883 void *argp1 = 0 ;
30884 int res1 = 0 ;
30885 int temp2 ;
30886 int res2 = SWIG_TMPOBJ ;
30887 int temp3 ;
30888 int res3 = SWIG_TMPOBJ ;
30889 PyObject *swig_obj[1] ;
30890
30891 arg2 = &temp2;
30892 arg3 = &temp3;
30893 if (!args) SWIG_fail;
30894 swig_obj[0] = args;
30895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30896 if (!SWIG_IsOK(res1)) {
30897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30898 }
30899 arg1 = reinterpret_cast< wxWindow * >(argp1);
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30903 wxPyEndAllowThreads(__tstate);
30904 if (PyErr_Occurred()) SWIG_fail;
30905 }
30906 resultobj = SWIG_Py_Void();
30907 if (SWIG_IsTmpObj(res2)) {
30908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30909 } else {
30910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30912 }
30913 if (SWIG_IsTmpObj(res3)) {
30914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30915 } else {
30916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30926 PyObject *resultobj = 0;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 wxPoint result;
30929 void *argp1 = 0 ;
30930 int res1 = 0 ;
30931 PyObject *swig_obj[1] ;
30932
30933 if (!args) SWIG_fail;
30934 swig_obj[0] = args;
30935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30936 if (!SWIG_IsOK(res1)) {
30937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30938 }
30939 arg1 = reinterpret_cast< wxWindow * >(argp1);
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = ((wxWindow const *)arg1)->GetScreenPosition();
30943 wxPyEndAllowThreads(__tstate);
30944 if (PyErr_Occurred()) SWIG_fail;
30945 }
30946 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30954 PyObject *resultobj = 0;
30955 wxWindow *arg1 = (wxWindow *) 0 ;
30956 int *arg2 = (int *) 0 ;
30957 int *arg3 = (int *) 0 ;
30958 void *argp1 = 0 ;
30959 int res1 = 0 ;
30960 int temp2 ;
30961 int res2 = SWIG_TMPOBJ ;
30962 int temp3 ;
30963 int res3 = SWIG_TMPOBJ ;
30964 PyObject *swig_obj[1] ;
30965
30966 arg2 = &temp2;
30967 arg3 = &temp3;
30968 if (!args) SWIG_fail;
30969 swig_obj[0] = args;
30970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30971 if (!SWIG_IsOK(res1)) {
30972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30973 }
30974 arg1 = reinterpret_cast< wxWindow * >(argp1);
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 resultobj = SWIG_Py_Void();
30982 if (SWIG_IsTmpObj(res2)) {
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30984 } else {
30985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30987 }
30988 if (SWIG_IsTmpObj(res3)) {
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30990 } else {
30991 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30993 }
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31001 PyObject *resultobj = 0;
31002 wxWindow *arg1 = (wxWindow *) 0 ;
31003 wxRect result;
31004 void *argp1 = 0 ;
31005 int res1 = 0 ;
31006 PyObject *swig_obj[1] ;
31007
31008 if (!args) SWIG_fail;
31009 swig_obj[0] = args;
31010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31011 if (!SWIG_IsOK(res1)) {
31012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31013 }
31014 arg1 = reinterpret_cast< wxWindow * >(argp1);
31015 {
31016 PyThreadState* __tstate = wxPyBeginAllowThreads();
31017 result = ((wxWindow const *)arg1)->GetScreenRect();
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31029 PyObject *resultobj = 0;
31030 wxWindow *arg1 = (wxWindow *) 0 ;
31031 wxSize result;
31032 void *argp1 = 0 ;
31033 int res1 = 0 ;
31034 PyObject *swig_obj[1] ;
31035
31036 if (!args) SWIG_fail;
31037 swig_obj[0] = args;
31038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31041 }
31042 arg1 = reinterpret_cast< wxWindow * >(argp1);
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 result = ((wxWindow const *)arg1)->GetSize();
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31057 PyObject *resultobj = 0;
31058 wxWindow *arg1 = (wxWindow *) 0 ;
31059 int *arg2 = (int *) 0 ;
31060 int *arg3 = (int *) 0 ;
31061 void *argp1 = 0 ;
31062 int res1 = 0 ;
31063 int temp2 ;
31064 int res2 = SWIG_TMPOBJ ;
31065 int temp3 ;
31066 int res3 = SWIG_TMPOBJ ;
31067 PyObject *swig_obj[1] ;
31068
31069 arg2 = &temp2;
31070 arg3 = &temp3;
31071 if (!args) SWIG_fail;
31072 swig_obj[0] = args;
31073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31074 if (!SWIG_IsOK(res1)) {
31075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31076 }
31077 arg1 = reinterpret_cast< wxWindow * >(argp1);
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_Py_Void();
31085 if (SWIG_IsTmpObj(res2)) {
31086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31087 } else {
31088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31090 }
31091 if (SWIG_IsTmpObj(res3)) {
31092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31093 } else {
31094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31096 }
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 wxRect result;
31107 void *argp1 = 0 ;
31108 int res1 = 0 ;
31109 PyObject *swig_obj[1] ;
31110
31111 if (!args) SWIG_fail;
31112 swig_obj[0] = args;
31113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 result = ((wxWindow const *)arg1)->GetRect();
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31132 PyObject *resultobj = 0;
31133 wxWindow *arg1 = (wxWindow *) 0 ;
31134 wxSize result;
31135 void *argp1 = 0 ;
31136 int res1 = 0 ;
31137 PyObject *swig_obj[1] ;
31138
31139 if (!args) SWIG_fail;
31140 swig_obj[0] = args;
31141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31142 if (!SWIG_IsOK(res1)) {
31143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31144 }
31145 arg1 = reinterpret_cast< wxWindow * >(argp1);
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = ((wxWindow const *)arg1)->GetClientSize();
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31160 PyObject *resultobj = 0;
31161 wxWindow *arg1 = (wxWindow *) 0 ;
31162 int *arg2 = (int *) 0 ;
31163 int *arg3 = (int *) 0 ;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 int temp2 ;
31167 int res2 = SWIG_TMPOBJ ;
31168 int temp3 ;
31169 int res3 = SWIG_TMPOBJ ;
31170 PyObject *swig_obj[1] ;
31171
31172 arg2 = &temp2;
31173 arg3 = &temp3;
31174 if (!args) SWIG_fail;
31175 swig_obj[0] = args;
31176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31177 if (!SWIG_IsOK(res1)) {
31178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31179 }
31180 arg1 = reinterpret_cast< wxWindow * >(argp1);
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 if (SWIG_IsTmpObj(res2)) {
31189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31190 } else {
31191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31193 }
31194 if (SWIG_IsTmpObj(res3)) {
31195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31196 } else {
31197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31199 }
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 wxPoint result;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 PyObject *swig_obj[1] ;
31213
31214 if (!args) SWIG_fail;
31215 swig_obj[0] = args;
31216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31219 }
31220 arg1 = reinterpret_cast< wxWindow * >(argp1);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31228 return resultobj;
31229 fail:
31230 return NULL;
31231 }
31232
31233
31234 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31235 PyObject *resultobj = 0;
31236 wxWindow *arg1 = (wxWindow *) 0 ;
31237 wxRect result;
31238 void *argp1 = 0 ;
31239 int res1 = 0 ;
31240 PyObject *swig_obj[1] ;
31241
31242 if (!args) SWIG_fail;
31243 swig_obj[0] = args;
31244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31245 if (!SWIG_IsOK(res1)) {
31246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31247 }
31248 arg1 = reinterpret_cast< wxWindow * >(argp1);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = ((wxWindow const *)arg1)->GetClientRect();
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31263 PyObject *resultobj = 0;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 wxSize result;
31266 void *argp1 = 0 ;
31267 int res1 = 0 ;
31268 PyObject *swig_obj[1] ;
31269
31270 if (!args) SWIG_fail;
31271 swig_obj[0] = args;
31272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxWindow * >(argp1);
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = ((wxWindow const *)arg1)->GetBestSize();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 int *arg2 = (int *) 0 ;
31294 int *arg3 = (int *) 0 ;
31295 void *argp1 = 0 ;
31296 int res1 = 0 ;
31297 int temp2 ;
31298 int res2 = SWIG_TMPOBJ ;
31299 int temp3 ;
31300 int res3 = SWIG_TMPOBJ ;
31301 PyObject *swig_obj[1] ;
31302
31303 arg2 = &temp2;
31304 arg3 = &temp3;
31305 if (!args) SWIG_fail;
31306 swig_obj[0] = args;
31307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31308 if (!SWIG_IsOK(res1)) {
31309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31310 }
31311 arg1 = reinterpret_cast< wxWindow * >(argp1);
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 resultobj = SWIG_Py_Void();
31319 if (SWIG_IsTmpObj(res2)) {
31320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31321 } else {
31322 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31324 }
31325 if (SWIG_IsTmpObj(res3)) {
31326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31327 } else {
31328 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31330 }
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 PyObject *resultobj = 0;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 void *argp1 = 0 ;
31341 int res1 = 0 ;
31342 PyObject *swig_obj[1] ;
31343
31344 if (!args) SWIG_fail;
31345 swig_obj[0] = args;
31346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31347 if (!SWIG_IsOK(res1)) {
31348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31349 }
31350 arg1 = reinterpret_cast< wxWindow * >(argp1);
31351 {
31352 PyThreadState* __tstate = wxPyBeginAllowThreads();
31353 (arg1)->InvalidateBestSize();
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 resultobj = SWIG_Py_Void();
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj = 0;
31366 wxWindow *arg1 = (wxWindow *) 0 ;
31367 wxSize *arg2 = 0 ;
31368 void *argp1 = 0 ;
31369 int res1 = 0 ;
31370 wxSize temp2 ;
31371 PyObject * obj0 = 0 ;
31372 PyObject * obj1 = 0 ;
31373 char * kwnames[] = {
31374 (char *) "self",(char *) "size", NULL
31375 };
31376
31377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31381 }
31382 arg1 = reinterpret_cast< wxWindow * >(argp1);
31383 {
31384 arg2 = &temp2;
31385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31386 }
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 resultobj = SWIG_Py_Void();
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31401 PyObject *resultobj = 0;
31402 wxWindow *arg1 = (wxWindow *) 0 ;
31403 wxSize result;
31404 void *argp1 = 0 ;
31405 int res1 = 0 ;
31406 PyObject *swig_obj[1] ;
31407
31408 if (!args) SWIG_fail;
31409 swig_obj[0] = args;
31410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31411 if (!SWIG_IsOK(res1)) {
31412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31413 }
31414 arg1 = reinterpret_cast< wxWindow * >(argp1);
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31429 PyObject *resultobj = 0;
31430 wxWindow *arg1 = (wxWindow *) 0 ;
31431 wxSize result;
31432 void *argp1 = 0 ;
31433 int res1 = 0 ;
31434 PyObject *swig_obj[1] ;
31435
31436 if (!args) SWIG_fail;
31437 swig_obj[0] = args;
31438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31439 if (!SWIG_IsOK(res1)) {
31440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31441 }
31442 arg1 = reinterpret_cast< wxWindow * >(argp1);
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj = 0;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 int arg2 = (int) wxBOTH ;
31460 void *argp1 = 0 ;
31461 int res1 = 0 ;
31462 int val2 ;
31463 int ecode2 = 0 ;
31464 PyObject * obj0 = 0 ;
31465 PyObject * obj1 = 0 ;
31466 char * kwnames[] = {
31467 (char *) "self",(char *) "direction", NULL
31468 };
31469
31470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31472 if (!SWIG_IsOK(res1)) {
31473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31474 }
31475 arg1 = reinterpret_cast< wxWindow * >(argp1);
31476 if (obj1) {
31477 ecode2 = SWIG_AsVal_int(obj1, &val2);
31478 if (!SWIG_IsOK(ecode2)) {
31479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31480 }
31481 arg2 = static_cast< int >(val2);
31482 }
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 (arg1)->Center(arg2);
31486 wxPyEndAllowThreads(__tstate);
31487 if (PyErr_Occurred()) SWIG_fail;
31488 }
31489 resultobj = SWIG_Py_Void();
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31497 PyObject *resultobj = 0;
31498 wxWindow *arg1 = (wxWindow *) 0 ;
31499 int arg2 = (int) wxBOTH ;
31500 void *argp1 = 0 ;
31501 int res1 = 0 ;
31502 int val2 ;
31503 int ecode2 = 0 ;
31504 PyObject * obj0 = 0 ;
31505 PyObject * obj1 = 0 ;
31506 char * kwnames[] = {
31507 (char *) "self",(char *) "dir", NULL
31508 };
31509
31510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31512 if (!SWIG_IsOK(res1)) {
31513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31514 }
31515 arg1 = reinterpret_cast< wxWindow * >(argp1);
31516 if (obj1) {
31517 ecode2 = SWIG_AsVal_int(obj1, &val2);
31518 if (!SWIG_IsOK(ecode2)) {
31519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31520 }
31521 arg2 = static_cast< int >(val2);
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 (arg1)->CenterOnParent(arg2);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_Py_Void();
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31537 PyObject *resultobj = 0;
31538 wxWindow *arg1 = (wxWindow *) 0 ;
31539 void *argp1 = 0 ;
31540 int res1 = 0 ;
31541 PyObject *swig_obj[1] ;
31542
31543 if (!args) SWIG_fail;
31544 swig_obj[0] = args;
31545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31546 if (!SWIG_IsOK(res1)) {
31547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31548 }
31549 arg1 = reinterpret_cast< wxWindow * >(argp1);
31550 {
31551 PyThreadState* __tstate = wxPyBeginAllowThreads();
31552 (arg1)->Fit();
31553 wxPyEndAllowThreads(__tstate);
31554 if (PyErr_Occurred()) SWIG_fail;
31555 }
31556 resultobj = SWIG_Py_Void();
31557 return resultobj;
31558 fail:
31559 return NULL;
31560 }
31561
31562
31563 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31564 PyObject *resultobj = 0;
31565 wxWindow *arg1 = (wxWindow *) 0 ;
31566 void *argp1 = 0 ;
31567 int res1 = 0 ;
31568 PyObject *swig_obj[1] ;
31569
31570 if (!args) SWIG_fail;
31571 swig_obj[0] = args;
31572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31573 if (!SWIG_IsOK(res1)) {
31574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31575 }
31576 arg1 = reinterpret_cast< wxWindow * >(argp1);
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->FitInside();
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_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 int arg2 ;
31594 int arg3 ;
31595 int arg4 = (int) -1 ;
31596 int arg5 = (int) -1 ;
31597 int arg6 = (int) -1 ;
31598 int arg7 = (int) -1 ;
31599 void *argp1 = 0 ;
31600 int res1 = 0 ;
31601 int val2 ;
31602 int ecode2 = 0 ;
31603 int val3 ;
31604 int ecode3 = 0 ;
31605 int val4 ;
31606 int ecode4 = 0 ;
31607 int val5 ;
31608 int ecode5 = 0 ;
31609 int val6 ;
31610 int ecode6 = 0 ;
31611 int val7 ;
31612 int ecode7 = 0 ;
31613 PyObject * obj0 = 0 ;
31614 PyObject * obj1 = 0 ;
31615 PyObject * obj2 = 0 ;
31616 PyObject * obj3 = 0 ;
31617 PyObject * obj4 = 0 ;
31618 PyObject * obj5 = 0 ;
31619 PyObject * obj6 = 0 ;
31620 char * kwnames[] = {
31621 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31622 };
31623
31624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31628 }
31629 arg1 = reinterpret_cast< wxWindow * >(argp1);
31630 ecode2 = SWIG_AsVal_int(obj1, &val2);
31631 if (!SWIG_IsOK(ecode2)) {
31632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31633 }
31634 arg2 = static_cast< int >(val2);
31635 ecode3 = SWIG_AsVal_int(obj2, &val3);
31636 if (!SWIG_IsOK(ecode3)) {
31637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31638 }
31639 arg3 = static_cast< int >(val3);
31640 if (obj3) {
31641 ecode4 = SWIG_AsVal_int(obj3, &val4);
31642 if (!SWIG_IsOK(ecode4)) {
31643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31644 }
31645 arg4 = static_cast< int >(val4);
31646 }
31647 if (obj4) {
31648 ecode5 = SWIG_AsVal_int(obj4, &val5);
31649 if (!SWIG_IsOK(ecode5)) {
31650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31651 }
31652 arg5 = static_cast< int >(val5);
31653 }
31654 if (obj5) {
31655 ecode6 = SWIG_AsVal_int(obj5, &val6);
31656 if (!SWIG_IsOK(ecode6)) {
31657 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31658 }
31659 arg6 = static_cast< int >(val6);
31660 }
31661 if (obj6) {
31662 ecode7 = SWIG_AsVal_int(obj6, &val7);
31663 if (!SWIG_IsOK(ecode7)) {
31664 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31665 }
31666 arg7 = static_cast< int >(val7);
31667 }
31668 {
31669 PyThreadState* __tstate = wxPyBeginAllowThreads();
31670 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31671 wxPyEndAllowThreads(__tstate);
31672 if (PyErr_Occurred()) SWIG_fail;
31673 }
31674 resultobj = SWIG_Py_Void();
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj = 0;
31683 wxWindow *arg1 = (wxWindow *) 0 ;
31684 wxSize *arg2 = 0 ;
31685 wxSize const &arg3_defvalue = wxDefaultSize ;
31686 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31687 wxSize const &arg4_defvalue = wxDefaultSize ;
31688 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 wxSize temp2 ;
31692 wxSize temp3 ;
31693 wxSize temp4 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 PyObject * obj2 = 0 ;
31697 PyObject * obj3 = 0 ;
31698 char * kwnames[] = {
31699 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31700 };
31701
31702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31706 }
31707 arg1 = reinterpret_cast< wxWindow * >(argp1);
31708 {
31709 arg2 = &temp2;
31710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31711 }
31712 if (obj2) {
31713 {
31714 arg3 = &temp3;
31715 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31716 }
31717 }
31718 if (obj3) {
31719 {
31720 arg4 = &temp4;
31721 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31722 }
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_Py_Void();
31731 return resultobj;
31732 fail:
31733 return NULL;
31734 }
31735
31736
31737 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31738 PyObject *resultobj = 0;
31739 wxWindow *arg1 = (wxWindow *) 0 ;
31740 int arg2 ;
31741 int arg3 ;
31742 int arg4 = (int) -1 ;
31743 int arg5 = (int) -1 ;
31744 void *argp1 = 0 ;
31745 int res1 = 0 ;
31746 int val2 ;
31747 int ecode2 = 0 ;
31748 int val3 ;
31749 int ecode3 = 0 ;
31750 int val4 ;
31751 int ecode4 = 0 ;
31752 int val5 ;
31753 int ecode5 = 0 ;
31754 PyObject * obj0 = 0 ;
31755 PyObject * obj1 = 0 ;
31756 PyObject * obj2 = 0 ;
31757 PyObject * obj3 = 0 ;
31758 PyObject * obj4 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31767 }
31768 arg1 = reinterpret_cast< wxWindow * >(argp1);
31769 ecode2 = SWIG_AsVal_int(obj1, &val2);
31770 if (!SWIG_IsOK(ecode2)) {
31771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31772 }
31773 arg2 = static_cast< int >(val2);
31774 ecode3 = SWIG_AsVal_int(obj2, &val3);
31775 if (!SWIG_IsOK(ecode3)) {
31776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31777 }
31778 arg3 = static_cast< int >(val3);
31779 if (obj3) {
31780 ecode4 = SWIG_AsVal_int(obj3, &val4);
31781 if (!SWIG_IsOK(ecode4)) {
31782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31783 }
31784 arg4 = static_cast< int >(val4);
31785 }
31786 if (obj4) {
31787 ecode5 = SWIG_AsVal_int(obj4, &val5);
31788 if (!SWIG_IsOK(ecode5)) {
31789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31790 }
31791 arg5 = static_cast< int >(val5);
31792 }
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_Py_Void();
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31807 PyObject *resultobj = 0;
31808 wxWindow *arg1 = (wxWindow *) 0 ;
31809 wxSize *arg2 = 0 ;
31810 wxSize const &arg3_defvalue = wxDefaultSize ;
31811 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 wxSize temp2 ;
31815 wxSize temp3 ;
31816 PyObject * obj0 = 0 ;
31817 PyObject * obj1 = 0 ;
31818 PyObject * obj2 = 0 ;
31819 char * kwnames[] = {
31820 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31821 };
31822
31823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 arg2 = &temp2;
31831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31832 }
31833 if (obj2) {
31834 {
31835 arg3 = &temp3;
31836 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31837 }
31838 }
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 resultobj = SWIG_Py_Void();
31846 return resultobj;
31847 fail:
31848 return NULL;
31849 }
31850
31851
31852 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31853 PyObject *resultobj = 0;
31854 wxWindow *arg1 = (wxWindow *) 0 ;
31855 wxSize result;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 PyObject *swig_obj[1] ;
31859
31860 if (!args) SWIG_fail;
31861 swig_obj[0] = args;
31862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31865 }
31866 arg1 = reinterpret_cast< wxWindow * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = ((wxWindow const *)arg1)->GetMaxSize();
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 wxSize result;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 PyObject *swig_obj[1] ;
31887
31888 if (!args) SWIG_fail;
31889 swig_obj[0] = args;
31890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31893 }
31894 arg1 = reinterpret_cast< wxWindow * >(argp1);
31895 {
31896 PyThreadState* __tstate = wxPyBeginAllowThreads();
31897 result = ((wxWindow const *)arg1)->GetMinSize();
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31909 PyObject *resultobj = 0;
31910 wxWindow *arg1 = (wxWindow *) 0 ;
31911 wxSize *arg2 = 0 ;
31912 void *argp1 = 0 ;
31913 int res1 = 0 ;
31914 wxSize temp2 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 char * kwnames[] = {
31918 (char *) "self",(char *) "minSize", NULL
31919 };
31920
31921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31923 if (!SWIG_IsOK(res1)) {
31924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31925 }
31926 arg1 = reinterpret_cast< wxWindow * >(argp1);
31927 {
31928 arg2 = &temp2;
31929 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31930 }
31931 {
31932 PyThreadState* __tstate = wxPyBeginAllowThreads();
31933 (arg1)->SetMinSize((wxSize const &)*arg2);
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 resultobj = SWIG_Py_Void();
31938 return resultobj;
31939 fail:
31940 return NULL;
31941 }
31942
31943
31944 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31945 PyObject *resultobj = 0;
31946 wxWindow *arg1 = (wxWindow *) 0 ;
31947 wxSize *arg2 = 0 ;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 wxSize temp2 ;
31951 PyObject * obj0 = 0 ;
31952 PyObject * obj1 = 0 ;
31953 char * kwnames[] = {
31954 (char *) "self",(char *) "maxSize", NULL
31955 };
31956
31957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31959 if (!SWIG_IsOK(res1)) {
31960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31961 }
31962 arg1 = reinterpret_cast< wxWindow * >(argp1);
31963 {
31964 arg2 = &temp2;
31965 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31966 }
31967 {
31968 PyThreadState* __tstate = wxPyBeginAllowThreads();
31969 (arg1)->SetMaxSize((wxSize const &)*arg2);
31970 wxPyEndAllowThreads(__tstate);
31971 if (PyErr_Occurred()) SWIG_fail;
31972 }
31973 resultobj = SWIG_Py_Void();
31974 return resultobj;
31975 fail:
31976 return NULL;
31977 }
31978
31979
31980 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31981 PyObject *resultobj = 0;
31982 wxWindow *arg1 = (wxWindow *) 0 ;
31983 int result;
31984 void *argp1 = 0 ;
31985 int res1 = 0 ;
31986 PyObject *swig_obj[1] ;
31987
31988 if (!args) SWIG_fail;
31989 swig_obj[0] = args;
31990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31991 if (!SWIG_IsOK(res1)) {
31992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31993 }
31994 arg1 = reinterpret_cast< wxWindow * >(argp1);
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 resultobj = SWIG_From_int(static_cast< int >(result));
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32009 PyObject *resultobj = 0;
32010 wxWindow *arg1 = (wxWindow *) 0 ;
32011 int result;
32012 void *argp1 = 0 ;
32013 int res1 = 0 ;
32014 PyObject *swig_obj[1] ;
32015
32016 if (!args) SWIG_fail;
32017 swig_obj[0] = args;
32018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32019 if (!SWIG_IsOK(res1)) {
32020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32021 }
32022 arg1 = reinterpret_cast< wxWindow * >(argp1);
32023 {
32024 PyThreadState* __tstate = wxPyBeginAllowThreads();
32025 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32026 wxPyEndAllowThreads(__tstate);
32027 if (PyErr_Occurred()) SWIG_fail;
32028 }
32029 resultobj = SWIG_From_int(static_cast< int >(result));
32030 return resultobj;
32031 fail:
32032 return NULL;
32033 }
32034
32035
32036 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32037 PyObject *resultobj = 0;
32038 wxWindow *arg1 = (wxWindow *) 0 ;
32039 int result;
32040 void *argp1 = 0 ;
32041 int res1 = 0 ;
32042 PyObject *swig_obj[1] ;
32043
32044 if (!args) SWIG_fail;
32045 swig_obj[0] = args;
32046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_From_int(static_cast< int >(result));
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32065 PyObject *resultobj = 0;
32066 wxWindow *arg1 = (wxWindow *) 0 ;
32067 int result;
32068 void *argp1 = 0 ;
32069 int res1 = 0 ;
32070 PyObject *swig_obj[1] ;
32071
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_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32077 }
32078 arg1 = reinterpret_cast< wxWindow * >(argp1);
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32082 wxPyEndAllowThreads(__tstate);
32083 if (PyErr_Occurred()) SWIG_fail;
32084 }
32085 resultobj = SWIG_From_int(static_cast< int >(result));
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj = 0;
32094 wxWindow *arg1 = (wxWindow *) 0 ;
32095 wxSize *arg2 = 0 ;
32096 void *argp1 = 0 ;
32097 int res1 = 0 ;
32098 wxSize temp2 ;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 char * kwnames[] = {
32102 (char *) "self",(char *) "size", NULL
32103 };
32104
32105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32109 }
32110 arg1 = reinterpret_cast< wxWindow * >(argp1);
32111 {
32112 arg2 = &temp2;
32113 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_Py_Void();
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32129 PyObject *resultobj = 0;
32130 wxWindow *arg1 = (wxWindow *) 0 ;
32131 int arg2 ;
32132 int arg3 ;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 int val2 ;
32136 int ecode2 = 0 ;
32137 int val3 ;
32138 int ecode3 = 0 ;
32139 PyObject * obj0 = 0 ;
32140 PyObject * obj1 = 0 ;
32141 PyObject * obj2 = 0 ;
32142 char * kwnames[] = {
32143 (char *) "self",(char *) "w",(char *) "h", NULL
32144 };
32145
32146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32148 if (!SWIG_IsOK(res1)) {
32149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32150 }
32151 arg1 = reinterpret_cast< wxWindow * >(argp1);
32152 ecode2 = SWIG_AsVal_int(obj1, &val2);
32153 if (!SWIG_IsOK(ecode2)) {
32154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32155 }
32156 arg2 = static_cast< int >(val2);
32157 ecode3 = SWIG_AsVal_int(obj2, &val3);
32158 if (!SWIG_IsOK(ecode3)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32160 }
32161 arg3 = static_cast< int >(val3);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 (arg1)->SetVirtualSize(arg2,arg3);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = SWIG_Py_Void();
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32176 PyObject *resultobj = 0;
32177 wxWindow *arg1 = (wxWindow *) 0 ;
32178 wxSize result;
32179 void *argp1 = 0 ;
32180 int res1 = 0 ;
32181 PyObject *swig_obj[1] ;
32182
32183 if (!args) SWIG_fail;
32184 swig_obj[0] = args;
32185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32188 }
32189 arg1 = reinterpret_cast< wxWindow * >(argp1);
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = ((wxWindow const *)arg1)->GetVirtualSize();
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxWindow *arg1 = (wxWindow *) 0 ;
32206 int *arg2 = (int *) 0 ;
32207 int *arg3 = (int *) 0 ;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 int temp2 ;
32211 int res2 = SWIG_TMPOBJ ;
32212 int temp3 ;
32213 int res3 = SWIG_TMPOBJ ;
32214 PyObject *swig_obj[1] ;
32215
32216 arg2 = &temp2;
32217 arg3 = &temp3;
32218 if (!args) SWIG_fail;
32219 swig_obj[0] = args;
32220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32221 if (!SWIG_IsOK(res1)) {
32222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32223 }
32224 arg1 = reinterpret_cast< wxWindow * >(argp1);
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 resultobj = SWIG_Py_Void();
32232 if (SWIG_IsTmpObj(res2)) {
32233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32234 } else {
32235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32237 }
32238 if (SWIG_IsTmpObj(res3)) {
32239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32240 } else {
32241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32243 }
32244 return resultobj;
32245 fail:
32246 return NULL;
32247 }
32248
32249
32250 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32251 PyObject *resultobj = 0;
32252 wxWindow *arg1 = (wxWindow *) 0 ;
32253 wxSize result;
32254 void *argp1 = 0 ;
32255 int res1 = 0 ;
32256 PyObject *swig_obj[1] ;
32257
32258 if (!args) SWIG_fail;
32259 swig_obj[0] = args;
32260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32261 if (!SWIG_IsOK(res1)) {
32262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32263 }
32264 arg1 = reinterpret_cast< wxWindow * >(argp1);
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32279 PyObject *resultobj = 0;
32280 wxWindow *arg1 = (wxWindow *) 0 ;
32281 bool arg2 = (bool) true ;
32282 bool result;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 bool val2 ;
32286 int ecode2 = 0 ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 char * kwnames[] = {
32290 (char *) "self",(char *) "show", NULL
32291 };
32292
32293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32297 }
32298 arg1 = reinterpret_cast< wxWindow * >(argp1);
32299 if (obj1) {
32300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32301 if (!SWIG_IsOK(ecode2)) {
32302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32303 }
32304 arg2 = static_cast< bool >(val2);
32305 }
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (bool)(arg1)->Show(arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 {
32313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32314 }
32315 return resultobj;
32316 fail:
32317 return NULL;
32318 }
32319
32320
32321 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32322 PyObject *resultobj = 0;
32323 wxWindow *arg1 = (wxWindow *) 0 ;
32324 bool result;
32325 void *argp1 = 0 ;
32326 int res1 = 0 ;
32327 PyObject *swig_obj[1] ;
32328
32329 if (!args) SWIG_fail;
32330 swig_obj[0] = args;
32331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32332 if (!SWIG_IsOK(res1)) {
32333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32334 }
32335 arg1 = reinterpret_cast< wxWindow * >(argp1);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (bool)(arg1)->Hide();
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 {
32343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32344 }
32345 return resultobj;
32346 fail:
32347 return NULL;
32348 }
32349
32350
32351 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32352 PyObject *resultobj = 0;
32353 wxWindow *arg1 = (wxWindow *) 0 ;
32354 bool arg2 = (bool) true ;
32355 bool result;
32356 void *argp1 = 0 ;
32357 int res1 = 0 ;
32358 bool val2 ;
32359 int ecode2 = 0 ;
32360 PyObject * obj0 = 0 ;
32361 PyObject * obj1 = 0 ;
32362 char * kwnames[] = {
32363 (char *) "self",(char *) "enable", NULL
32364 };
32365
32366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32368 if (!SWIG_IsOK(res1)) {
32369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32370 }
32371 arg1 = reinterpret_cast< wxWindow * >(argp1);
32372 if (obj1) {
32373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32374 if (!SWIG_IsOK(ecode2)) {
32375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32376 }
32377 arg2 = static_cast< bool >(val2);
32378 }
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 result = (bool)(arg1)->Enable(arg2);
32382 wxPyEndAllowThreads(__tstate);
32383 if (PyErr_Occurred()) SWIG_fail;
32384 }
32385 {
32386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32387 }
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 bool result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (bool)(arg1)->Disable();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32425 PyObject *resultobj = 0;
32426 wxWindow *arg1 = (wxWindow *) 0 ;
32427 bool result;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32437 }
32438 arg1 = reinterpret_cast< wxWindow * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = (bool)((wxWindow const *)arg1)->IsShown();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 {
32446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32447 }
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxWindow *arg1 = (wxWindow *) 0 ;
32457 bool result;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 PyObject *swig_obj[1] ;
32461
32462 if (!args) SWIG_fail;
32463 swig_obj[0] = args;
32464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32465 if (!SWIG_IsOK(res1)) {
32466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32467 }
32468 arg1 = reinterpret_cast< wxWindow * >(argp1);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 {
32476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32477 }
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32485 PyObject *resultobj = 0;
32486 wxWindow *arg1 = (wxWindow *) 0 ;
32487 long arg2 ;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 long val2 ;
32491 int ecode2 = 0 ;
32492 PyObject * obj0 = 0 ;
32493 PyObject * obj1 = 0 ;
32494 char * kwnames[] = {
32495 (char *) "self",(char *) "style", NULL
32496 };
32497
32498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32500 if (!SWIG_IsOK(res1)) {
32501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32502 }
32503 arg1 = reinterpret_cast< wxWindow * >(argp1);
32504 ecode2 = SWIG_AsVal_long(obj1, &val2);
32505 if (!SWIG_IsOK(ecode2)) {
32506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32507 }
32508 arg2 = static_cast< long >(val2);
32509 {
32510 PyThreadState* __tstate = wxPyBeginAllowThreads();
32511 (arg1)->SetWindowStyleFlag(arg2);
32512 wxPyEndAllowThreads(__tstate);
32513 if (PyErr_Occurred()) SWIG_fail;
32514 }
32515 resultobj = SWIG_Py_Void();
32516 return resultobj;
32517 fail:
32518 return NULL;
32519 }
32520
32521
32522 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32523 PyObject *resultobj = 0;
32524 wxWindow *arg1 = (wxWindow *) 0 ;
32525 long result;
32526 void *argp1 = 0 ;
32527 int res1 = 0 ;
32528 PyObject *swig_obj[1] ;
32529
32530 if (!args) SWIG_fail;
32531 swig_obj[0] = args;
32532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32533 if (!SWIG_IsOK(res1)) {
32534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32535 }
32536 arg1 = reinterpret_cast< wxWindow * >(argp1);
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32540 wxPyEndAllowThreads(__tstate);
32541 if (PyErr_Occurred()) SWIG_fail;
32542 }
32543 resultobj = SWIG_From_long(static_cast< long >(result));
32544 return resultobj;
32545 fail:
32546 return NULL;
32547 }
32548
32549
32550 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32551 PyObject *resultobj = 0;
32552 wxWindow *arg1 = (wxWindow *) 0 ;
32553 int arg2 ;
32554 bool result;
32555 void *argp1 = 0 ;
32556 int res1 = 0 ;
32557 int val2 ;
32558 int ecode2 = 0 ;
32559 PyObject * obj0 = 0 ;
32560 PyObject * obj1 = 0 ;
32561 char * kwnames[] = {
32562 (char *) "self",(char *) "flag", NULL
32563 };
32564
32565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 ecode2 = SWIG_AsVal_int(obj1, &val2);
32572 if (!SWIG_IsOK(ecode2)) {
32573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32574 }
32575 arg2 = static_cast< int >(val2);
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 {
32583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32584 }
32585 return resultobj;
32586 fail:
32587 return NULL;
32588 }
32589
32590
32591 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32592 PyObject *resultobj = 0;
32593 wxWindow *arg1 = (wxWindow *) 0 ;
32594 bool result;
32595 void *argp1 = 0 ;
32596 int res1 = 0 ;
32597 PyObject *swig_obj[1] ;
32598
32599 if (!args) SWIG_fail;
32600 swig_obj[0] = args;
32601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32602 if (!SWIG_IsOK(res1)) {
32603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32604 }
32605 arg1 = reinterpret_cast< wxWindow * >(argp1);
32606 {
32607 PyThreadState* __tstate = wxPyBeginAllowThreads();
32608 result = (bool)((wxWindow const *)arg1)->IsRetained();
32609 wxPyEndAllowThreads(__tstate);
32610 if (PyErr_Occurred()) SWIG_fail;
32611 }
32612 {
32613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32614 }
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = 0;
32623 wxWindow *arg1 = (wxWindow *) 0 ;
32624 long arg2 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 long val2 ;
32628 int ecode2 = 0 ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "exStyle", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32639 }
32640 arg1 = reinterpret_cast< wxWindow * >(argp1);
32641 ecode2 = SWIG_AsVal_long(obj1, &val2);
32642 if (!SWIG_IsOK(ecode2)) {
32643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32644 }
32645 arg2 = static_cast< long >(val2);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 (arg1)->SetExtraStyle(arg2);
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_Py_Void();
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 long result;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 PyObject *swig_obj[1] ;
32666
32667 if (!args) SWIG_fail;
32668 swig_obj[0] = args;
32669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32670 if (!SWIG_IsOK(res1)) {
32671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32672 }
32673 arg1 = reinterpret_cast< wxWindow * >(argp1);
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 resultobj = SWIG_From_long(static_cast< long >(result));
32681 return resultobj;
32682 fail:
32683 return NULL;
32684 }
32685
32686
32687 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32688 PyObject *resultobj = 0;
32689 wxWindow *arg1 = (wxWindow *) 0 ;
32690 bool arg2 = (bool) true ;
32691 void *argp1 = 0 ;
32692 int res1 = 0 ;
32693 bool val2 ;
32694 int ecode2 = 0 ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "modal", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 if (obj1) {
32708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32709 if (!SWIG_IsOK(ecode2)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32711 }
32712 arg2 = static_cast< bool >(val2);
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 (arg1)->MakeModal(arg2);
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_Py_Void();
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32728 PyObject *resultobj = 0;
32729 wxWindow *arg1 = (wxWindow *) 0 ;
32730 bool arg2 ;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 bool val2 ;
32734 int ecode2 = 0 ;
32735 PyObject * obj0 = 0 ;
32736 PyObject * obj1 = 0 ;
32737 char * kwnames[] = {
32738 (char *) "self",(char *) "enableTheme", NULL
32739 };
32740
32741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32743 if (!SWIG_IsOK(res1)) {
32744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32745 }
32746 arg1 = reinterpret_cast< wxWindow * >(argp1);
32747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32748 if (!SWIG_IsOK(ecode2)) {
32749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32750 }
32751 arg2 = static_cast< bool >(val2);
32752 {
32753 PyThreadState* __tstate = wxPyBeginAllowThreads();
32754 (arg1)->SetThemeEnabled(arg2);
32755 wxPyEndAllowThreads(__tstate);
32756 if (PyErr_Occurred()) SWIG_fail;
32757 }
32758 resultobj = SWIG_Py_Void();
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32766 PyObject *resultobj = 0;
32767 wxWindow *arg1 = (wxWindow *) 0 ;
32768 bool result;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 PyObject *swig_obj[1] ;
32772
32773 if (!args) SWIG_fail;
32774 swig_obj[0] = args;
32775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32776 if (!SWIG_IsOK(res1)) {
32777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32778 }
32779 arg1 = reinterpret_cast< wxWindow * >(argp1);
32780 {
32781 PyThreadState* __tstate = wxPyBeginAllowThreads();
32782 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32783 wxPyEndAllowThreads(__tstate);
32784 if (PyErr_Occurred()) SWIG_fail;
32785 }
32786 {
32787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32788 }
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 PyObject *resultobj = 0;
32797 wxWindow *arg1 = (wxWindow *) 0 ;
32798 void *argp1 = 0 ;
32799 int res1 = 0 ;
32800 PyObject *swig_obj[1] ;
32801
32802 if (!args) SWIG_fail;
32803 swig_obj[0] = args;
32804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 (arg1)->SetFocus();
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 resultobj = SWIG_Py_Void();
32816 return resultobj;
32817 fail:
32818 return NULL;
32819 }
32820
32821
32822 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32823 PyObject *resultobj = 0;
32824 wxWindow *arg1 = (wxWindow *) 0 ;
32825 void *argp1 = 0 ;
32826 int res1 = 0 ;
32827 PyObject *swig_obj[1] ;
32828
32829 if (!args) SWIG_fail;
32830 swig_obj[0] = args;
32831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32832 if (!SWIG_IsOK(res1)) {
32833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32834 }
32835 arg1 = reinterpret_cast< wxWindow * >(argp1);
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 (arg1)->SetFocusFromKbd();
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 resultobj = SWIG_Py_Void();
32843 return resultobj;
32844 fail:
32845 return NULL;
32846 }
32847
32848
32849 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32850 PyObject *resultobj = 0;
32851 wxWindow *result = 0 ;
32852
32853 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32854 {
32855 if (!wxPyCheckForApp()) SWIG_fail;
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 result = (wxWindow *)wxWindow::FindFocus();
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 {
32862 resultobj = wxPyMake_wxObject(result, 0);
32863 }
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 bool result;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 PyObject *swig_obj[1] ;
32877
32878 if (!args) SWIG_fail;
32879 swig_obj[0] = args;
32880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32883 }
32884 arg1 = reinterpret_cast< wxWindow * >(argp1);
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 {
32892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32893 }
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32901 PyObject *resultobj = 0;
32902 wxWindow *arg1 = (wxWindow *) 0 ;
32903 bool result;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 PyObject *swig_obj[1] ;
32907
32908 if (!args) SWIG_fail;
32909 swig_obj[0] = args;
32910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 {
32922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32923 }
32924 return resultobj;
32925 fail:
32926 return NULL;
32927 }
32928
32929
32930 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32931 PyObject *resultobj = 0;
32932 wxWindow *arg1 = (wxWindow *) 0 ;
32933 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32934 bool result;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 int val2 ;
32938 int ecode2 = 0 ;
32939 PyObject * obj0 = 0 ;
32940 PyObject * obj1 = 0 ;
32941 char * kwnames[] = {
32942 (char *) "self",(char *) "flags", NULL
32943 };
32944
32945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 if (obj1) {
32952 ecode2 = SWIG_AsVal_int(obj1, &val2);
32953 if (!SWIG_IsOK(ecode2)) {
32954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32955 }
32956 arg2 = static_cast< int >(val2);
32957 }
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 result = (bool)(arg1)->Navigate(arg2);
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 {
32965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32966 }
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32974 PyObject *resultobj = 0;
32975 wxWindow *arg1 = (wxWindow *) 0 ;
32976 wxWindow *arg2 = (wxWindow *) 0 ;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 void *argp2 = 0 ;
32980 int res2 = 0 ;
32981 PyObject * obj0 = 0 ;
32982 PyObject * obj1 = 0 ;
32983 char * kwnames[] = {
32984 (char *) "self",(char *) "win", NULL
32985 };
32986
32987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32989 if (!SWIG_IsOK(res1)) {
32990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32991 }
32992 arg1 = reinterpret_cast< wxWindow * >(argp1);
32993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32994 if (!SWIG_IsOK(res2)) {
32995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32996 }
32997 arg2 = reinterpret_cast< wxWindow * >(argp2);
32998 {
32999 PyThreadState* __tstate = wxPyBeginAllowThreads();
33000 (arg1)->MoveAfterInTabOrder(arg2);
33001 wxPyEndAllowThreads(__tstate);
33002 if (PyErr_Occurred()) SWIG_fail;
33003 }
33004 resultobj = SWIG_Py_Void();
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 wxWindow *arg2 = (wxWindow *) 0 ;
33015 void *argp1 = 0 ;
33016 int res1 = 0 ;
33017 void *argp2 = 0 ;
33018 int res2 = 0 ;
33019 PyObject * obj0 = 0 ;
33020 PyObject * obj1 = 0 ;
33021 char * kwnames[] = {
33022 (char *) "self",(char *) "win", NULL
33023 };
33024
33025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",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_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33029 }
33030 arg1 = reinterpret_cast< wxWindow * >(argp1);
33031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33032 if (!SWIG_IsOK(res2)) {
33033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33034 }
33035 arg2 = reinterpret_cast< wxWindow * >(argp2);
33036 {
33037 PyThreadState* __tstate = wxPyBeginAllowThreads();
33038 (arg1)->MoveBeforeInTabOrder(arg2);
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 resultobj = SWIG_Py_Void();
33043 return resultobj;
33044 fail:
33045 return NULL;
33046 }
33047
33048
33049 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33050 PyObject *resultobj = 0;
33051 wxWindow *arg1 = (wxWindow *) 0 ;
33052 PyObject *result = 0 ;
33053 void *argp1 = 0 ;
33054 int res1 = 0 ;
33055 PyObject *swig_obj[1] ;
33056
33057 if (!args) SWIG_fail;
33058 swig_obj[0] = args;
33059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33060 if (!SWIG_IsOK(res1)) {
33061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33062 }
33063 arg1 = reinterpret_cast< wxWindow * >(argp1);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 result = (PyObject *)wxWindow_GetChildren(arg1);
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = result;
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 wxWindow *result = 0 ;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 PyObject *swig_obj[1] ;
33084
33085 if (!args) SWIG_fail;
33086 swig_obj[0] = args;
33087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 {
33099 resultobj = wxPyMake_wxObject(result, 0);
33100 }
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 wxWindow *result = 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 PyObject *swig_obj[1] ;
33114
33115 if (!args) SWIG_fail;
33116 swig_obj[0] = args;
33117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33120 }
33121 arg1 = reinterpret_cast< wxWindow * >(argp1);
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 {
33129 resultobj = wxPyMake_wxObject(result, 0);
33130 }
33131 return resultobj;
33132 fail:
33133 return NULL;
33134 }
33135
33136
33137 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33138 PyObject *resultobj = 0;
33139 wxWindow *arg1 = (wxWindow *) 0 ;
33140 bool result;
33141 void *argp1 = 0 ;
33142 int res1 = 0 ;
33143 PyObject *swig_obj[1] ;
33144
33145 if (!args) SWIG_fail;
33146 swig_obj[0] = args;
33147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33148 if (!SWIG_IsOK(res1)) {
33149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33150 }
33151 arg1 = reinterpret_cast< wxWindow * >(argp1);
33152 {
33153 PyThreadState* __tstate = wxPyBeginAllowThreads();
33154 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 {
33159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33160 }
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj = 0;
33169 wxWindow *arg1 = (wxWindow *) 0 ;
33170 wxWindow *arg2 = (wxWindow *) 0 ;
33171 bool result;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 void *argp2 = 0 ;
33175 int res2 = 0 ;
33176 PyObject * obj0 = 0 ;
33177 PyObject * obj1 = 0 ;
33178 char * kwnames[] = {
33179 (char *) "self",(char *) "newParent", NULL
33180 };
33181
33182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res1)) {
33185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33186 }
33187 arg1 = reinterpret_cast< wxWindow * >(argp1);
33188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33189 if (!SWIG_IsOK(res2)) {
33190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33191 }
33192 arg2 = reinterpret_cast< wxWindow * >(argp2);
33193 {
33194 PyThreadState* __tstate = wxPyBeginAllowThreads();
33195 result = (bool)(arg1)->Reparent(arg2);
33196 wxPyEndAllowThreads(__tstate);
33197 if (PyErr_Occurred()) SWIG_fail;
33198 }
33199 {
33200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33201 }
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33209 PyObject *resultobj = 0;
33210 wxWindow *arg1 = (wxWindow *) 0 ;
33211 wxWindow *arg2 = (wxWindow *) 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 void *argp2 = 0 ;
33215 int res2 = 0 ;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 char * kwnames[] = {
33219 (char *) "self",(char *) "child", NULL
33220 };
33221
33222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33226 }
33227 arg1 = reinterpret_cast< wxWindow * >(argp1);
33228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33229 if (!SWIG_IsOK(res2)) {
33230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33231 }
33232 arg2 = reinterpret_cast< wxWindow * >(argp2);
33233 {
33234 PyThreadState* __tstate = wxPyBeginAllowThreads();
33235 (arg1)->AddChild(arg2);
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 resultobj = SWIG_Py_Void();
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj = 0;
33248 wxWindow *arg1 = (wxWindow *) 0 ;
33249 wxWindow *arg2 = (wxWindow *) 0 ;
33250 void *argp1 = 0 ;
33251 int res1 = 0 ;
33252 void *argp2 = 0 ;
33253 int res2 = 0 ;
33254 PyObject * obj0 = 0 ;
33255 PyObject * obj1 = 0 ;
33256 char * kwnames[] = {
33257 (char *) "self",(char *) "child", NULL
33258 };
33259
33260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33262 if (!SWIG_IsOK(res1)) {
33263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33264 }
33265 arg1 = reinterpret_cast< wxWindow * >(argp1);
33266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33267 if (!SWIG_IsOK(res2)) {
33268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33269 }
33270 arg2 = reinterpret_cast< wxWindow * >(argp2);
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 (arg1)->RemoveChild(arg2);
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 resultobj = SWIG_Py_Void();
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33285 PyObject *resultobj = 0;
33286 wxWindow *arg1 = (wxWindow *) 0 ;
33287 bool arg2 ;
33288 void *argp1 = 0 ;
33289 int res1 = 0 ;
33290 bool val2 ;
33291 int ecode2 = 0 ;
33292 PyObject * obj0 = 0 ;
33293 PyObject * obj1 = 0 ;
33294 char * kwnames[] = {
33295 (char *) "self",(char *) "on", NULL
33296 };
33297
33298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33302 }
33303 arg1 = reinterpret_cast< wxWindow * >(argp1);
33304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33305 if (!SWIG_IsOK(ecode2)) {
33306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33307 }
33308 arg2 = static_cast< bool >(val2);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 wxWindow_SetDoubleBuffered(arg1,arg2);
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_Py_Void();
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33323 PyObject *resultobj = 0;
33324 wxWindow *arg1 = (wxWindow *) 0 ;
33325 long arg2 ;
33326 wxWindow *result = 0 ;
33327 void *argp1 = 0 ;
33328 int res1 = 0 ;
33329 long val2 ;
33330 int ecode2 = 0 ;
33331 PyObject * obj0 = 0 ;
33332 PyObject * obj1 = 0 ;
33333 char * kwnames[] = {
33334 (char *) "self",(char *) "winid", NULL
33335 };
33336
33337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33339 if (!SWIG_IsOK(res1)) {
33340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33341 }
33342 arg1 = reinterpret_cast< wxWindow * >(argp1);
33343 ecode2 = SWIG_AsVal_long(obj1, &val2);
33344 if (!SWIG_IsOK(ecode2)) {
33345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33346 }
33347 arg2 = static_cast< long >(val2);
33348 {
33349 PyThreadState* __tstate = wxPyBeginAllowThreads();
33350 result = (wxWindow *)(arg1)->FindWindow(arg2);
33351 wxPyEndAllowThreads(__tstate);
33352 if (PyErr_Occurred()) SWIG_fail;
33353 }
33354 {
33355 resultobj = wxPyMake_wxObject(result, 0);
33356 }
33357 return resultobj;
33358 fail:
33359 return NULL;
33360 }
33361
33362
33363 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33364 PyObject *resultobj = 0;
33365 wxWindow *arg1 = (wxWindow *) 0 ;
33366 wxString *arg2 = 0 ;
33367 wxWindow *result = 0 ;
33368 void *argp1 = 0 ;
33369 int res1 = 0 ;
33370 bool temp2 = false ;
33371 PyObject * obj0 = 0 ;
33372 PyObject * obj1 = 0 ;
33373 char * kwnames[] = {
33374 (char *) "self",(char *) "name", NULL
33375 };
33376
33377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 {
33384 arg2 = wxString_in_helper(obj1);
33385 if (arg2 == NULL) SWIG_fail;
33386 temp2 = true;
33387 }
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 {
33395 resultobj = wxPyMake_wxObject(result, 0);
33396 }
33397 {
33398 if (temp2)
33399 delete arg2;
33400 }
33401 return resultobj;
33402 fail:
33403 {
33404 if (temp2)
33405 delete arg2;
33406 }
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33412 PyObject *resultobj = 0;
33413 wxWindow *arg1 = (wxWindow *) 0 ;
33414 wxEvtHandler *result = 0 ;
33415 void *argp1 = 0 ;
33416 int res1 = 0 ;
33417 PyObject *swig_obj[1] ;
33418
33419 if (!args) SWIG_fail;
33420 swig_obj[0] = args;
33421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33422 if (!SWIG_IsOK(res1)) {
33423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33424 }
33425 arg1 = reinterpret_cast< wxWindow * >(argp1);
33426 {
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 {
33433 resultobj = wxPyMake_wxObject(result, 0);
33434 }
33435 return resultobj;
33436 fail:
33437 return NULL;
33438 }
33439
33440
33441 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33442 PyObject *resultobj = 0;
33443 wxWindow *arg1 = (wxWindow *) 0 ;
33444 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33445 void *argp1 = 0 ;
33446 int res1 = 0 ;
33447 void *argp2 = 0 ;
33448 int res2 = 0 ;
33449 PyObject * obj0 = 0 ;
33450 PyObject * obj1 = 0 ;
33451 char * kwnames[] = {
33452 (char *) "self",(char *) "handler", NULL
33453 };
33454
33455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33459 }
33460 arg1 = reinterpret_cast< wxWindow * >(argp1);
33461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33462 if (!SWIG_IsOK(res2)) {
33463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33464 }
33465 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33466 {
33467 PyThreadState* __tstate = wxPyBeginAllowThreads();
33468 (arg1)->SetEventHandler(arg2);
33469 wxPyEndAllowThreads(__tstate);
33470 if (PyErr_Occurred()) SWIG_fail;
33471 }
33472 resultobj = SWIG_Py_Void();
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = 0;
33481 wxWindow *arg1 = (wxWindow *) 0 ;
33482 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33483 void *argp1 = 0 ;
33484 int res1 = 0 ;
33485 void *argp2 = 0 ;
33486 int res2 = 0 ;
33487 PyObject * obj0 = 0 ;
33488 PyObject * obj1 = 0 ;
33489 char * kwnames[] = {
33490 (char *) "self",(char *) "handler", NULL
33491 };
33492
33493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33495 if (!SWIG_IsOK(res1)) {
33496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33497 }
33498 arg1 = reinterpret_cast< wxWindow * >(argp1);
33499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33500 if (!SWIG_IsOK(res2)) {
33501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33502 }
33503 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 (arg1)->PushEventHandler(arg2);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 resultobj = SWIG_Py_Void();
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 bool arg2 = (bool) false ;
33521 wxEvtHandler *result = 0 ;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 bool val2 ;
33525 int ecode2 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "self",(char *) "deleteHandler", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 if (obj1) {
33539 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33540 if (!SWIG_IsOK(ecode2)) {
33541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33542 }
33543 arg2 = static_cast< bool >(val2);
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 {
33552 resultobj = wxPyMake_wxObject(result, 0);
33553 }
33554 return resultobj;
33555 fail:
33556 return NULL;
33557 }
33558
33559
33560 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33561 PyObject *resultobj = 0;
33562 wxWindow *arg1 = (wxWindow *) 0 ;
33563 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33564 bool result;
33565 void *argp1 = 0 ;
33566 int res1 = 0 ;
33567 void *argp2 = 0 ;
33568 int res2 = 0 ;
33569 PyObject * obj0 = 0 ;
33570 PyObject * obj1 = 0 ;
33571 char * kwnames[] = {
33572 (char *) "self",(char *) "handler", NULL
33573 };
33574
33575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33577 if (!SWIG_IsOK(res1)) {
33578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33579 }
33580 arg1 = reinterpret_cast< wxWindow * >(argp1);
33581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33582 if (!SWIG_IsOK(res2)) {
33583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33584 }
33585 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33586 {
33587 PyThreadState* __tstate = wxPyBeginAllowThreads();
33588 result = (bool)(arg1)->RemoveEventHandler(arg2);
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 {
33593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33594 }
33595 return resultobj;
33596 fail:
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33602 PyObject *resultobj = 0;
33603 wxWindow *arg1 = (wxWindow *) 0 ;
33604 wxValidator *arg2 = 0 ;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 void *argp2 = 0 ;
33608 int res2 = 0 ;
33609 PyObject * obj0 = 0 ;
33610 PyObject * obj1 = 0 ;
33611 char * kwnames[] = {
33612 (char *) "self",(char *) "validator", NULL
33613 };
33614
33615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33617 if (!SWIG_IsOK(res1)) {
33618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33619 }
33620 arg1 = reinterpret_cast< wxWindow * >(argp1);
33621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33622 if (!SWIG_IsOK(res2)) {
33623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33624 }
33625 if (!argp2) {
33626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33627 }
33628 arg2 = reinterpret_cast< wxValidator * >(argp2);
33629 {
33630 PyThreadState* __tstate = wxPyBeginAllowThreads();
33631 (arg1)->SetValidator((wxValidator const &)*arg2);
33632 wxPyEndAllowThreads(__tstate);
33633 if (PyErr_Occurred()) SWIG_fail;
33634 }
33635 resultobj = SWIG_Py_Void();
33636 return resultobj;
33637 fail:
33638 return NULL;
33639 }
33640
33641
33642 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33643 PyObject *resultobj = 0;
33644 wxWindow *arg1 = (wxWindow *) 0 ;
33645 wxValidator *result = 0 ;
33646 void *argp1 = 0 ;
33647 int res1 = 0 ;
33648 PyObject *swig_obj[1] ;
33649
33650 if (!args) SWIG_fail;
33651 swig_obj[0] = args;
33652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33653 if (!SWIG_IsOK(res1)) {
33654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33655 }
33656 arg1 = reinterpret_cast< wxWindow * >(argp1);
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 result = (wxValidator *)(arg1)->GetValidator();
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 {
33664 resultobj = wxPyMake_wxObject(result, (bool)0);
33665 }
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33673 PyObject *resultobj = 0;
33674 wxWindow *arg1 = (wxWindow *) 0 ;
33675 bool result;
33676 void *argp1 = 0 ;
33677 int res1 = 0 ;
33678 PyObject *swig_obj[1] ;
33679
33680 if (!args) SWIG_fail;
33681 swig_obj[0] = args;
33682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33683 if (!SWIG_IsOK(res1)) {
33684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33685 }
33686 arg1 = reinterpret_cast< wxWindow * >(argp1);
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 result = (bool)(arg1)->Validate();
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 {
33694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33695 }
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 bool result;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 PyObject *swig_obj[1] ;
33709
33710 if (!args) SWIG_fail;
33711 swig_obj[0] = args;
33712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33715 }
33716 arg1 = reinterpret_cast< wxWindow * >(argp1);
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 result = (bool)(arg1)->TransferDataToWindow();
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 {
33724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33725 }
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33733 PyObject *resultobj = 0;
33734 wxWindow *arg1 = (wxWindow *) 0 ;
33735 bool result;
33736 void *argp1 = 0 ;
33737 int res1 = 0 ;
33738 PyObject *swig_obj[1] ;
33739
33740 if (!args) SWIG_fail;
33741 swig_obj[0] = args;
33742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33743 if (!SWIG_IsOK(res1)) {
33744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33745 }
33746 arg1 = reinterpret_cast< wxWindow * >(argp1);
33747 {
33748 PyThreadState* __tstate = wxPyBeginAllowThreads();
33749 result = (bool)(arg1)->TransferDataFromWindow();
33750 wxPyEndAllowThreads(__tstate);
33751 if (PyErr_Occurred()) SWIG_fail;
33752 }
33753 {
33754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33755 }
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33763 PyObject *resultobj = 0;
33764 wxWindow *arg1 = (wxWindow *) 0 ;
33765 void *argp1 = 0 ;
33766 int res1 = 0 ;
33767 PyObject *swig_obj[1] ;
33768
33769 if (!args) SWIG_fail;
33770 swig_obj[0] = args;
33771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33772 if (!SWIG_IsOK(res1)) {
33773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33774 }
33775 arg1 = reinterpret_cast< wxWindow * >(argp1);
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->InitDialog();
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj = 0;
33791 wxWindow *arg1 = (wxWindow *) 0 ;
33792 wxAcceleratorTable *arg2 = 0 ;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 void *argp2 = 0 ;
33796 int res2 = 0 ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 char * kwnames[] = {
33800 (char *) "self",(char *) "accel", NULL
33801 };
33802
33803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33805 if (!SWIG_IsOK(res1)) {
33806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33807 }
33808 arg1 = reinterpret_cast< wxWindow * >(argp1);
33809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33810 if (!SWIG_IsOK(res2)) {
33811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33812 }
33813 if (!argp2) {
33814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33815 }
33816 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33817 {
33818 PyThreadState* __tstate = wxPyBeginAllowThreads();
33819 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 resultobj = SWIG_Py_Void();
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33831 PyObject *resultobj = 0;
33832 wxWindow *arg1 = (wxWindow *) 0 ;
33833 wxAcceleratorTable *result = 0 ;
33834 void *argp1 = 0 ;
33835 int res1 = 0 ;
33836 PyObject *swig_obj[1] ;
33837
33838 if (!args) SWIG_fail;
33839 swig_obj[0] = args;
33840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33843 }
33844 arg1 = reinterpret_cast< wxWindow * >(argp1);
33845 {
33846 PyThreadState* __tstate = wxPyBeginAllowThreads();
33847 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33848 wxPyEndAllowThreads(__tstate);
33849 if (PyErr_Occurred()) SWIG_fail;
33850 }
33851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = 0;
33860 wxWindow *arg1 = (wxWindow *) 0 ;
33861 int arg2 ;
33862 int arg3 ;
33863 int arg4 ;
33864 bool result;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 int val2 ;
33868 int ecode2 = 0 ;
33869 int val3 ;
33870 int ecode3 = 0 ;
33871 int val4 ;
33872 int ecode4 = 0 ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 PyObject * obj3 = 0 ;
33877 char * kwnames[] = {
33878 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33879 };
33880
33881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 ecode2 = SWIG_AsVal_int(obj1, &val2);
33888 if (!SWIG_IsOK(ecode2)) {
33889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33890 }
33891 arg2 = static_cast< int >(val2);
33892 ecode3 = SWIG_AsVal_int(obj2, &val3);
33893 if (!SWIG_IsOK(ecode3)) {
33894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33895 }
33896 arg3 = static_cast< int >(val3);
33897 ecode4 = SWIG_AsVal_int(obj3, &val4);
33898 if (!SWIG_IsOK(ecode4)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33900 }
33901 arg4 = static_cast< int >(val4);
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 {
33909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33910 }
33911 return resultobj;
33912 fail:
33913 return NULL;
33914 }
33915
33916
33917 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33918 PyObject *resultobj = 0;
33919 wxWindow *arg1 = (wxWindow *) 0 ;
33920 int arg2 ;
33921 bool result;
33922 void *argp1 = 0 ;
33923 int res1 = 0 ;
33924 int val2 ;
33925 int ecode2 = 0 ;
33926 PyObject * obj0 = 0 ;
33927 PyObject * obj1 = 0 ;
33928 char * kwnames[] = {
33929 (char *) "self",(char *) "hotkeyId", NULL
33930 };
33931
33932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33934 if (!SWIG_IsOK(res1)) {
33935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33936 }
33937 arg1 = reinterpret_cast< wxWindow * >(argp1);
33938 ecode2 = SWIG_AsVal_int(obj1, &val2);
33939 if (!SWIG_IsOK(ecode2)) {
33940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33941 }
33942 arg2 = static_cast< int >(val2);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 {
33950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33951 }
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 wxPoint *arg2 = 0 ;
33962 wxPoint result;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 wxPoint temp2 ;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 char * kwnames[] = {
33969 (char *) "self",(char *) "pt", NULL
33970 };
33971
33972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33976 }
33977 arg1 = reinterpret_cast< wxWindow * >(argp1);
33978 {
33979 arg2 = &temp2;
33980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33981 }
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33996 PyObject *resultobj = 0;
33997 wxWindow *arg1 = (wxWindow *) 0 ;
33998 wxSize *arg2 = 0 ;
33999 wxSize result;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 wxSize temp2 ;
34003 PyObject * obj0 = 0 ;
34004 PyObject * obj1 = 0 ;
34005 char * kwnames[] = {
34006 (char *) "self",(char *) "sz", NULL
34007 };
34008
34009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34013 }
34014 arg1 = reinterpret_cast< wxWindow * >(argp1);
34015 {
34016 arg2 = &temp2;
34017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34018 }
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj = 0;
34034 wxWindow *arg1 = (wxWindow *) 0 ;
34035 wxPoint *arg2 = 0 ;
34036 wxPoint result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 wxPoint temp2 ;
34040 PyObject * obj0 = 0 ;
34041 PyObject * obj1 = 0 ;
34042 char * kwnames[] = {
34043 (char *) "self",(char *) "pt", NULL
34044 };
34045
34046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34048 if (!SWIG_IsOK(res1)) {
34049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34050 }
34051 arg1 = reinterpret_cast< wxWindow * >(argp1);
34052 {
34053 arg2 = &temp2;
34054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34055 }
34056 {
34057 PyThreadState* __tstate = wxPyBeginAllowThreads();
34058 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34063 return resultobj;
34064 fail:
34065 return NULL;
34066 }
34067
34068
34069 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34070 PyObject *resultobj = 0;
34071 wxWindow *arg1 = (wxWindow *) 0 ;
34072 wxSize *arg2 = 0 ;
34073 wxSize result;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 wxSize temp2 ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 char * kwnames[] = {
34080 (char *) "self",(char *) "sz", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 {
34090 arg2 = &temp2;
34091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34092 }
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxPoint *arg2 = 0 ;
34110 wxPoint result;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 wxPoint temp2 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char * kwnames[] = {
34117 (char *) "self",(char *) "pt", NULL
34118 };
34119
34120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 arg2 = &temp2;
34128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 wxSize *arg2 = 0 ;
34147 wxSize result;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 wxSize temp2 ;
34151 PyObject * obj0 = 0 ;
34152 PyObject * obj1 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "sz", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34161 }
34162 arg1 = reinterpret_cast< wxWindow * >(argp1);
34163 {
34164 arg2 = &temp2;
34165 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34166 }
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34174 return resultobj;
34175 fail:
34176 return NULL;
34177 }
34178
34179
34180 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34181 PyObject *resultobj = 0;
34182 wxWindow *arg1 = (wxWindow *) 0 ;
34183 int arg2 ;
34184 int arg3 ;
34185 void *argp1 = 0 ;
34186 int res1 = 0 ;
34187 int val2 ;
34188 int ecode2 = 0 ;
34189 int val3 ;
34190 int ecode3 = 0 ;
34191 PyObject * obj0 = 0 ;
34192 PyObject * obj1 = 0 ;
34193 PyObject * obj2 = 0 ;
34194 char * kwnames[] = {
34195 (char *) "self",(char *) "x",(char *) "y", NULL
34196 };
34197
34198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34202 }
34203 arg1 = reinterpret_cast< wxWindow * >(argp1);
34204 ecode2 = SWIG_AsVal_int(obj1, &val2);
34205 if (!SWIG_IsOK(ecode2)) {
34206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34207 }
34208 arg2 = static_cast< int >(val2);
34209 ecode3 = SWIG_AsVal_int(obj2, &val3);
34210 if (!SWIG_IsOK(ecode3)) {
34211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34212 }
34213 arg3 = static_cast< int >(val3);
34214 {
34215 PyThreadState* __tstate = wxPyBeginAllowThreads();
34216 (arg1)->WarpPointer(arg2,arg3);
34217 wxPyEndAllowThreads(__tstate);
34218 if (PyErr_Occurred()) SWIG_fail;
34219 }
34220 resultobj = SWIG_Py_Void();
34221 return resultobj;
34222 fail:
34223 return NULL;
34224 }
34225
34226
34227 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxWindow *arg1 = (wxWindow *) 0 ;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 PyObject *swig_obj[1] ;
34233
34234 if (!args) SWIG_fail;
34235 swig_obj[0] = args;
34236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34239 }
34240 arg1 = reinterpret_cast< wxWindow * >(argp1);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 (arg1)->CaptureMouse();
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_Py_Void();
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxWindow *arg1 = (wxWindow *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 PyObject *swig_obj[1] ;
34260
34261 if (!args) SWIG_fail;
34262 swig_obj[0] = args;
34263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 (arg1)->ReleaseMouse();
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34282 PyObject *resultobj = 0;
34283 wxWindow *result = 0 ;
34284
34285 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34286 {
34287 if (!wxPyCheckForApp()) SWIG_fail;
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (wxWindow *)wxWindow::GetCapture();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 {
34294 resultobj = wxPyMake_wxObject(result, 0);
34295 }
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34303 PyObject *resultobj = 0;
34304 wxWindow *arg1 = (wxWindow *) 0 ;
34305 bool result;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 PyObject *swig_obj[1] ;
34309
34310 if (!args) SWIG_fail;
34311 swig_obj[0] = args;
34312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34313 if (!SWIG_IsOK(res1)) {
34314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34315 }
34316 arg1 = reinterpret_cast< wxWindow * >(argp1);
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 result = (bool)((wxWindow const *)arg1)->HasCapture();
34320 wxPyEndAllowThreads(__tstate);
34321 if (PyErr_Occurred()) SWIG_fail;
34322 }
34323 {
34324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34325 }
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34333 PyObject *resultobj = 0;
34334 wxWindow *arg1 = (wxWindow *) 0 ;
34335 bool arg2 = (bool) true ;
34336 wxRect *arg3 = (wxRect *) NULL ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 bool val2 ;
34340 int ecode2 = 0 ;
34341 void *argp3 = 0 ;
34342 int res3 = 0 ;
34343 PyObject * obj0 = 0 ;
34344 PyObject * obj1 = 0 ;
34345 PyObject * obj2 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 if (obj1) {
34357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34358 if (!SWIG_IsOK(ecode2)) {
34359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34360 }
34361 arg2 = static_cast< bool >(val2);
34362 }
34363 if (obj2) {
34364 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34365 if (!SWIG_IsOK(res3)) {
34366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34367 }
34368 arg3 = reinterpret_cast< wxRect * >(argp3);
34369 }
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_Py_Void();
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34384 PyObject *resultobj = 0;
34385 wxWindow *arg1 = (wxWindow *) 0 ;
34386 wxRect *arg2 = 0 ;
34387 bool arg3 = (bool) true ;
34388 void *argp1 = 0 ;
34389 int res1 = 0 ;
34390 wxRect temp2 ;
34391 bool val3 ;
34392 int ecode3 = 0 ;
34393 PyObject * obj0 = 0 ;
34394 PyObject * obj1 = 0 ;
34395 PyObject * obj2 = 0 ;
34396 char * kwnames[] = {
34397 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34398 };
34399
34400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34404 }
34405 arg1 = reinterpret_cast< wxWindow * >(argp1);
34406 {
34407 arg2 = &temp2;
34408 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34409 }
34410 if (obj2) {
34411 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34412 if (!SWIG_IsOK(ecode3)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34414 }
34415 arg3 = static_cast< bool >(val3);
34416 }
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 resultobj = SWIG_Py_Void();
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *resultobj = 0;
34432 wxWindow *arg1 = (wxWindow *) 0 ;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 PyObject *swig_obj[1] ;
34436
34437 if (!args) SWIG_fail;
34438 swig_obj[0] = args;
34439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 (arg1)->Update();
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_Py_Void();
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34469 }
34470 arg1 = reinterpret_cast< wxWindow * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 (arg1)->ClearBackground();
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 resultobj = SWIG_Py_Void();
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34485 PyObject *resultobj = 0;
34486 wxWindow *arg1 = (wxWindow *) 0 ;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 PyObject *swig_obj[1] ;
34490
34491 if (!args) SWIG_fail;
34492 swig_obj[0] = args;
34493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34496 }
34497 arg1 = reinterpret_cast< wxWindow * >(argp1);
34498 {
34499 PyThreadState* __tstate = wxPyBeginAllowThreads();
34500 (arg1)->Freeze();
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 resultobj = SWIG_Py_Void();
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34512 PyObject *resultobj = 0;
34513 wxWindow *arg1 = (wxWindow *) 0 ;
34514 void *argp1 = 0 ;
34515 int res1 = 0 ;
34516 PyObject *swig_obj[1] ;
34517
34518 if (!args) SWIG_fail;
34519 swig_obj[0] = args;
34520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34521 if (!SWIG_IsOK(res1)) {
34522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34523 }
34524 arg1 = reinterpret_cast< wxWindow * >(argp1);
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 (arg1)->Thaw();
34528 wxPyEndAllowThreads(__tstate);
34529 if (PyErr_Occurred()) SWIG_fail;
34530 }
34531 resultobj = SWIG_Py_Void();
34532 return resultobj;
34533 fail:
34534 return NULL;
34535 }
34536
34537
34538 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34539 PyObject *resultobj = 0;
34540 wxWindow *arg1 = (wxWindow *) 0 ;
34541 wxDC *arg2 = 0 ;
34542 void *argp1 = 0 ;
34543 int res1 = 0 ;
34544 void *argp2 = 0 ;
34545 int res2 = 0 ;
34546 PyObject * obj0 = 0 ;
34547 PyObject * obj1 = 0 ;
34548 char * kwnames[] = {
34549 (char *) "self",(char *) "dc", NULL
34550 };
34551
34552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34556 }
34557 arg1 = reinterpret_cast< wxWindow * >(argp1);
34558 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34559 if (!SWIG_IsOK(res2)) {
34560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34561 }
34562 if (!argp2) {
34563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34564 }
34565 arg2 = reinterpret_cast< wxDC * >(argp2);
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 (arg1)->PrepareDC(*arg2);
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_Py_Void();
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34580 PyObject *resultobj = 0;
34581 wxWindow *arg1 = (wxWindow *) 0 ;
34582 wxRegion *result = 0 ;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 PyObject *swig_obj[1] ;
34586
34587 if (!args) SWIG_fail;
34588 swig_obj[0] = args;
34589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34590 if (!SWIG_IsOK(res1)) {
34591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34592 }
34593 arg1 = reinterpret_cast< wxWindow * >(argp1);
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 {
34597 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34598 result = (wxRegion *) &_result_ref;
34599 }
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 wxRect result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 int arg2 ;
34642 int arg3 ;
34643 int arg4 = (int) 1 ;
34644 int arg5 = (int) 1 ;
34645 bool result;
34646 void *argp1 = 0 ;
34647 int res1 = 0 ;
34648 int val2 ;
34649 int ecode2 = 0 ;
34650 int val3 ;
34651 int ecode3 = 0 ;
34652 int val4 ;
34653 int ecode4 = 0 ;
34654 int val5 ;
34655 int ecode5 = 0 ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 PyObject * obj2 = 0 ;
34659 PyObject * obj3 = 0 ;
34660 PyObject * obj4 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 ecode2 = SWIG_AsVal_int(obj1, &val2);
34672 if (!SWIG_IsOK(ecode2)) {
34673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34674 }
34675 arg2 = static_cast< int >(val2);
34676 ecode3 = SWIG_AsVal_int(obj2, &val3);
34677 if (!SWIG_IsOK(ecode3)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34679 }
34680 arg3 = static_cast< int >(val3);
34681 if (obj3) {
34682 ecode4 = SWIG_AsVal_int(obj3, &val4);
34683 if (!SWIG_IsOK(ecode4)) {
34684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34685 }
34686 arg4 = static_cast< int >(val4);
34687 }
34688 if (obj4) {
34689 ecode5 = SWIG_AsVal_int(obj4, &val5);
34690 if (!SWIG_IsOK(ecode5)) {
34691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34692 }
34693 arg5 = static_cast< int >(val5);
34694 }
34695 {
34696 PyThreadState* __tstate = wxPyBeginAllowThreads();
34697 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 {
34702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34703 }
34704 return resultobj;
34705 fail:
34706 return NULL;
34707 }
34708
34709
34710 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34711 PyObject *resultobj = 0;
34712 wxWindow *arg1 = (wxWindow *) 0 ;
34713 wxPoint *arg2 = 0 ;
34714 bool result;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 wxPoint temp2 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "pt", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 {
34731 arg2 = &temp2;
34732 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 {
34741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34742 }
34743 return resultobj;
34744 fail:
34745 return NULL;
34746 }
34747
34748
34749 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34750 PyObject *resultobj = 0;
34751 wxWindow *arg1 = (wxWindow *) 0 ;
34752 wxRect *arg2 = 0 ;
34753 bool result;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 wxRect temp2 ;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 char * kwnames[] = {
34760 (char *) "self",(char *) "rect", NULL
34761 };
34762
34763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 {
34770 arg2 = &temp2;
34771 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34772 }
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 {
34780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34781 }
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34789 PyObject *resultobj = 0;
34790 wxWindow *arg1 = (wxWindow *) 0 ;
34791 SwigValueWrapper<wxVisualAttributes > result;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 PyObject *swig_obj[1] ;
34795
34796 if (!args) SWIG_fail;
34797 swig_obj[0] = args;
34798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34801 }
34802 arg1 = reinterpret_cast< wxWindow * >(argp1);
34803 {
34804 PyThreadState* __tstate = wxPyBeginAllowThreads();
34805 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34806 wxPyEndAllowThreads(__tstate);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 }
34809 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34810 return resultobj;
34811 fail:
34812 return NULL;
34813 }
34814
34815
34816 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34817 PyObject *resultobj = 0;
34818 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34819 SwigValueWrapper<wxVisualAttributes > result;
34820 int val1 ;
34821 int ecode1 = 0 ;
34822 PyObject * obj0 = 0 ;
34823 char * kwnames[] = {
34824 (char *) "variant", NULL
34825 };
34826
34827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34828 if (obj0) {
34829 ecode1 = SWIG_AsVal_int(obj0, &val1);
34830 if (!SWIG_IsOK(ecode1)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34832 }
34833 arg1 = static_cast< wxWindowVariant >(val1);
34834 }
34835 {
34836 if (!wxPyCheckForApp()) SWIG_fail;
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 result = wxWindow::GetClassDefaultAttributes(arg1);
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxWindow *arg1 = (wxWindow *) 0 ;
34852 wxColour *arg2 = 0 ;
34853 bool result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 wxColour temp2 ;
34857 PyObject * obj0 = 0 ;
34858 PyObject * obj1 = 0 ;
34859 char * kwnames[] = {
34860 (char *) "self",(char *) "colour", NULL
34861 };
34862
34863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34865 if (!SWIG_IsOK(res1)) {
34866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34867 }
34868 arg1 = reinterpret_cast< wxWindow * >(argp1);
34869 {
34870 arg2 = &temp2;
34871 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34872 }
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 {
34880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34881 }
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34889 PyObject *resultobj = 0;
34890 wxWindow *arg1 = (wxWindow *) 0 ;
34891 wxColour *arg2 = 0 ;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 wxColour temp2 ;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 char * kwnames[] = {
34898 (char *) "self",(char *) "colour", NULL
34899 };
34900
34901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34903 if (!SWIG_IsOK(res1)) {
34904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34905 }
34906 arg1 = reinterpret_cast< wxWindow * >(argp1);
34907 {
34908 arg2 = &temp2;
34909 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34910 }
34911 {
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 resultobj = SWIG_Py_Void();
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34925 PyObject *resultobj = 0;
34926 wxWindow *arg1 = (wxWindow *) 0 ;
34927 wxColour *arg2 = 0 ;
34928 bool result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 wxColour temp2 ;
34932 PyObject * obj0 = 0 ;
34933 PyObject * obj1 = 0 ;
34934 char * kwnames[] = {
34935 (char *) "self",(char *) "colour", NULL
34936 };
34937
34938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34940 if (!SWIG_IsOK(res1)) {
34941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34942 }
34943 arg1 = reinterpret_cast< wxWindow * >(argp1);
34944 {
34945 arg2 = &temp2;
34946 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34947 }
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34951 wxPyEndAllowThreads(__tstate);
34952 if (PyErr_Occurred()) SWIG_fail;
34953 }
34954 {
34955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34956 }
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34964 PyObject *resultobj = 0;
34965 wxWindow *arg1 = (wxWindow *) 0 ;
34966 wxColour *arg2 = 0 ;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 wxColour temp2 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 char * kwnames[] = {
34973 (char *) "self",(char *) "colour", NULL
34974 };
34975
34976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34978 if (!SWIG_IsOK(res1)) {
34979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34980 }
34981 arg1 = reinterpret_cast< wxWindow * >(argp1);
34982 {
34983 arg2 = &temp2;
34984 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34985 }
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 resultobj = SWIG_Py_Void();
34993 return resultobj;
34994 fail:
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35000 PyObject *resultobj = 0;
35001 wxWindow *arg1 = (wxWindow *) 0 ;
35002 wxColour result;
35003 void *argp1 = 0 ;
35004 int res1 = 0 ;
35005 PyObject *swig_obj[1] ;
35006
35007 if (!args) SWIG_fail;
35008 swig_obj[0] = args;
35009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35010 if (!SWIG_IsOK(res1)) {
35011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35012 }
35013 arg1 = reinterpret_cast< wxWindow * >(argp1);
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35028 PyObject *resultobj = 0;
35029 wxWindow *arg1 = (wxWindow *) 0 ;
35030 wxColour result;
35031 void *argp1 = 0 ;
35032 int res1 = 0 ;
35033 PyObject *swig_obj[1] ;
35034
35035 if (!args) SWIG_fail;
35036 swig_obj[0] = args;
35037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35038 if (!SWIG_IsOK(res1)) {
35039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35040 }
35041 arg1 = reinterpret_cast< wxWindow * >(argp1);
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = ((wxWindow const *)arg1)->GetForegroundColour();
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 PyObject *resultobj = 0;
35057 wxWindow *arg1 = (wxWindow *) 0 ;
35058 bool result;
35059 void *argp1 = 0 ;
35060 int res1 = 0 ;
35061 PyObject *swig_obj[1] ;
35062
35063 if (!args) SWIG_fail;
35064 swig_obj[0] = args;
35065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35066 if (!SWIG_IsOK(res1)) {
35067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35068 }
35069 arg1 = reinterpret_cast< wxWindow * >(argp1);
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 {
35077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35078 }
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 bool result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 PyObject *swig_obj[1] ;
35092
35093 if (!args) SWIG_fail;
35094 swig_obj[0] = args;
35095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35096 if (!SWIG_IsOK(res1)) {
35097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35098 }
35099 arg1 = reinterpret_cast< wxWindow * >(argp1);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxBackgroundStyle arg2 ;
35119 bool result;
35120 void *argp1 = 0 ;
35121 int res1 = 0 ;
35122 int val2 ;
35123 int ecode2 = 0 ;
35124 PyObject * obj0 = 0 ;
35125 PyObject * obj1 = 0 ;
35126 char * kwnames[] = {
35127 (char *) "self",(char *) "style", NULL
35128 };
35129
35130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35134 }
35135 arg1 = reinterpret_cast< wxWindow * >(argp1);
35136 ecode2 = SWIG_AsVal_int(obj1, &val2);
35137 if (!SWIG_IsOK(ecode2)) {
35138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35139 }
35140 arg2 = static_cast< wxBackgroundStyle >(val2);
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 {
35148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35149 }
35150 return resultobj;
35151 fail:
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35157 PyObject *resultobj = 0;
35158 wxWindow *arg1 = (wxWindow *) 0 ;
35159 wxBackgroundStyle result;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 PyObject *swig_obj[1] ;
35163
35164 if (!args) SWIG_fail;
35165 swig_obj[0] = args;
35166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35167 if (!SWIG_IsOK(res1)) {
35168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35169 }
35170 arg1 = reinterpret_cast< wxWindow * >(argp1);
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 resultobj = SWIG_From_int(static_cast< int >(result));
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35185 PyObject *resultobj = 0;
35186 wxWindow *arg1 = (wxWindow *) 0 ;
35187 bool result;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 PyObject *swig_obj[1] ;
35191
35192 if (!args) SWIG_fail;
35193 swig_obj[0] = args;
35194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35195 if (!SWIG_IsOK(res1)) {
35196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35197 }
35198 arg1 = reinterpret_cast< wxWindow * >(argp1);
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 result = (bool)(arg1)->HasTransparentBackground();
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 {
35206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35207 }
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 wxCursor *arg2 = 0 ;
35218 bool result;
35219 void *argp1 = 0 ;
35220 int res1 = 0 ;
35221 void *argp2 = 0 ;
35222 int res2 = 0 ;
35223 PyObject * obj0 = 0 ;
35224 PyObject * obj1 = 0 ;
35225 char * kwnames[] = {
35226 (char *) "self",(char *) "cursor", NULL
35227 };
35228
35229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35231 if (!SWIG_IsOK(res1)) {
35232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35233 }
35234 arg1 = reinterpret_cast< wxWindow * >(argp1);
35235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35236 if (!SWIG_IsOK(res2)) {
35237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35238 }
35239 if (!argp2) {
35240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35241 }
35242 arg2 = reinterpret_cast< wxCursor * >(argp2);
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 {
35250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35251 }
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 wxCursor result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35271 }
35272 arg1 = reinterpret_cast< wxWindow * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (arg1)->GetCursor();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 wxFont *arg2 = 0 ;
35290 bool result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 void *argp2 = 0 ;
35294 int res2 = 0 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "font", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35308 if (!SWIG_IsOK(res2)) {
35309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35310 }
35311 if (!argp2) {
35312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35313 }
35314 arg2 = reinterpret_cast< wxFont * >(argp2);
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 {
35322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35323 }
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 wxFont *arg2 = 0 ;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 void *argp2 = 0 ;
35337 int res2 = 0 ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "font", NULL
35342 };
35343
35344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35348 }
35349 arg1 = reinterpret_cast< wxWindow * >(argp1);
35350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35351 if (!SWIG_IsOK(res2)) {
35352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35353 }
35354 if (!argp2) {
35355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35356 }
35357 arg2 = reinterpret_cast< wxFont * >(argp2);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 (arg1)->SetOwnFont((wxFont const &)*arg2);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_Py_Void();
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35372 PyObject *resultobj = 0;
35373 wxWindow *arg1 = (wxWindow *) 0 ;
35374 wxFont result;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 result = (arg1)->GetFont();
35389 wxPyEndAllowThreads(__tstate);
35390 if (PyErr_Occurred()) SWIG_fail;
35391 }
35392 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35400 PyObject *resultobj = 0;
35401 wxWindow *arg1 = (wxWindow *) 0 ;
35402 wxCaret *arg2 = (wxCaret *) 0 ;
35403 void *argp1 = 0 ;
35404 int res1 = 0 ;
35405 int res2 = 0 ;
35406 PyObject * obj0 = 0 ;
35407 PyObject * obj1 = 0 ;
35408 char * kwnames[] = {
35409 (char *) "self",(char *) "caret", NULL
35410 };
35411
35412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35414 if (!SWIG_IsOK(res1)) {
35415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35416 }
35417 arg1 = reinterpret_cast< wxWindow * >(argp1);
35418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35419 if (!SWIG_IsOK(res2)) {
35420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35421 }
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 (arg1)->SetCaret(arg2);
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_Py_Void();
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 wxCaret *result = 0 ;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 PyObject *swig_obj[1] ;
35442
35443 if (!args) SWIG_fail;
35444 swig_obj[0] = args;
35445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35446 if (!SWIG_IsOK(res1)) {
35447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35448 }
35449 arg1 = reinterpret_cast< wxWindow * >(argp1);
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35457 return resultobj;
35458 fail:
35459 return NULL;
35460 }
35461
35462
35463 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35464 PyObject *resultobj = 0;
35465 wxWindow *arg1 = (wxWindow *) 0 ;
35466 int result;
35467 void *argp1 = 0 ;
35468 int res1 = 0 ;
35469 PyObject *swig_obj[1] ;
35470
35471 if (!args) SWIG_fail;
35472 swig_obj[0] = args;
35473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35474 if (!SWIG_IsOK(res1)) {
35475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35476 }
35477 arg1 = reinterpret_cast< wxWindow * >(argp1);
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 resultobj = SWIG_From_int(static_cast< int >(result));
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35492 PyObject *resultobj = 0;
35493 wxWindow *arg1 = (wxWindow *) 0 ;
35494 int result;
35495 void *argp1 = 0 ;
35496 int res1 = 0 ;
35497 PyObject *swig_obj[1] ;
35498
35499 if (!args) SWIG_fail;
35500 swig_obj[0] = args;
35501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35502 if (!SWIG_IsOK(res1)) {
35503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35504 }
35505 arg1 = reinterpret_cast< wxWindow * >(argp1);
35506 {
35507 PyThreadState* __tstate = wxPyBeginAllowThreads();
35508 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35509 wxPyEndAllowThreads(__tstate);
35510 if (PyErr_Occurred()) SWIG_fail;
35511 }
35512 resultobj = SWIG_From_int(static_cast< int >(result));
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj = 0;
35521 wxWindow *arg1 = (wxWindow *) 0 ;
35522 wxString *arg2 = 0 ;
35523 int *arg3 = (int *) 0 ;
35524 int *arg4 = (int *) 0 ;
35525 void *argp1 = 0 ;
35526 int res1 = 0 ;
35527 bool temp2 = false ;
35528 int temp3 ;
35529 int res3 = SWIG_TMPOBJ ;
35530 int temp4 ;
35531 int res4 = SWIG_TMPOBJ ;
35532 PyObject * obj0 = 0 ;
35533 PyObject * obj1 = 0 ;
35534 char * kwnames[] = {
35535 (char *) "self",(char *) "string", NULL
35536 };
35537
35538 arg3 = &temp3;
35539 arg4 = &temp4;
35540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35544 }
35545 arg1 = reinterpret_cast< wxWindow * >(argp1);
35546 {
35547 arg2 = wxString_in_helper(obj1);
35548 if (arg2 == NULL) SWIG_fail;
35549 temp2 = true;
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 resultobj = SWIG_Py_Void();
35558 if (SWIG_IsTmpObj(res3)) {
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35560 } else {
35561 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35563 }
35564 if (SWIG_IsTmpObj(res4)) {
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35566 } else {
35567 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35569 }
35570 {
35571 if (temp2)
35572 delete arg2;
35573 }
35574 return resultobj;
35575 fail:
35576 {
35577 if (temp2)
35578 delete arg2;
35579 }
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35585 PyObject *resultobj = 0;
35586 wxWindow *arg1 = (wxWindow *) 0 ;
35587 wxString *arg2 = 0 ;
35588 int *arg3 = (int *) 0 ;
35589 int *arg4 = (int *) 0 ;
35590 int *arg5 = (int *) 0 ;
35591 int *arg6 = (int *) 0 ;
35592 wxFont *arg7 = (wxFont *) NULL ;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 bool temp2 = false ;
35596 int temp3 ;
35597 int res3 = SWIG_TMPOBJ ;
35598 int temp4 ;
35599 int res4 = SWIG_TMPOBJ ;
35600 int temp5 ;
35601 int res5 = SWIG_TMPOBJ ;
35602 int temp6 ;
35603 int res6 = SWIG_TMPOBJ ;
35604 void *argp7 = 0 ;
35605 int res7 = 0 ;
35606 PyObject * obj0 = 0 ;
35607 PyObject * obj1 = 0 ;
35608 PyObject * obj2 = 0 ;
35609 char * kwnames[] = {
35610 (char *) "self",(char *) "string",(char *) "font", NULL
35611 };
35612
35613 arg3 = &temp3;
35614 arg4 = &temp4;
35615 arg5 = &temp5;
35616 arg6 = &temp6;
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 {
35624 arg2 = wxString_in_helper(obj1);
35625 if (arg2 == NULL) SWIG_fail;
35626 temp2 = true;
35627 }
35628 if (obj2) {
35629 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35630 if (!SWIG_IsOK(res7)) {
35631 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35632 }
35633 arg7 = reinterpret_cast< wxFont * >(argp7);
35634 }
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 resultobj = SWIG_Py_Void();
35642 if (SWIG_IsTmpObj(res3)) {
35643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35644 } else {
35645 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35647 }
35648 if (SWIG_IsTmpObj(res4)) {
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35650 } else {
35651 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35653 }
35654 if (SWIG_IsTmpObj(res5)) {
35655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35656 } else {
35657 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35659 }
35660 if (SWIG_IsTmpObj(res6)) {
35661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35662 } else {
35663 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35665 }
35666 {
35667 if (temp2)
35668 delete arg2;
35669 }
35670 return resultobj;
35671 fail:
35672 {
35673 if (temp2)
35674 delete arg2;
35675 }
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35681 PyObject *resultobj = 0;
35682 wxWindow *arg1 = (wxWindow *) 0 ;
35683 int *arg2 = (int *) 0 ;
35684 int *arg3 = (int *) 0 ;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 int temp2 ;
35688 int res2 = 0 ;
35689 int temp3 ;
35690 int res3 = 0 ;
35691 PyObject * obj0 = 0 ;
35692 PyObject * obj1 = 0 ;
35693 PyObject * obj2 = 0 ;
35694 char * kwnames[] = {
35695 (char *) "self",(char *) "x",(char *) "y", NULL
35696 };
35697
35698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35702 }
35703 arg1 = reinterpret_cast< wxWindow * >(argp1);
35704 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35705 int val;
35706 int ecode = SWIG_AsVal_int(obj1, &val);
35707 if (!SWIG_IsOK(ecode)) {
35708 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35709 }
35710 temp2 = static_cast< int >(val);
35711 arg2 = &temp2;
35712 res2 = SWIG_AddTmpMask(ecode);
35713 }
35714 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35715 int val;
35716 int ecode = SWIG_AsVal_int(obj2, &val);
35717 if (!SWIG_IsOK(ecode)) {
35718 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35719 }
35720 temp3 = static_cast< int >(val);
35721 arg3 = &temp3;
35722 res3 = SWIG_AddTmpMask(ecode);
35723 }
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 resultobj = SWIG_Py_Void();
35731 if (SWIG_IsTmpObj(res2)) {
35732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35733 } else {
35734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35736 }
35737 if (SWIG_IsTmpObj(res3)) {
35738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35739 } else {
35740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35742 }
35743 return resultobj;
35744 fail:
35745 return NULL;
35746 }
35747
35748
35749 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35750 PyObject *resultobj = 0;
35751 wxWindow *arg1 = (wxWindow *) 0 ;
35752 int *arg2 = (int *) 0 ;
35753 int *arg3 = (int *) 0 ;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 int temp2 ;
35757 int res2 = 0 ;
35758 int temp3 ;
35759 int res3 = 0 ;
35760 PyObject * obj0 = 0 ;
35761 PyObject * obj1 = 0 ;
35762 PyObject * obj2 = 0 ;
35763 char * kwnames[] = {
35764 (char *) "self",(char *) "x",(char *) "y", NULL
35765 };
35766
35767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35774 int val;
35775 int ecode = SWIG_AsVal_int(obj1, &val);
35776 if (!SWIG_IsOK(ecode)) {
35777 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35778 }
35779 temp2 = static_cast< int >(val);
35780 arg2 = &temp2;
35781 res2 = SWIG_AddTmpMask(ecode);
35782 }
35783 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35784 int val;
35785 int ecode = SWIG_AsVal_int(obj2, &val);
35786 if (!SWIG_IsOK(ecode)) {
35787 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35788 }
35789 temp3 = static_cast< int >(val);
35790 arg3 = &temp3;
35791 res3 = SWIG_AddTmpMask(ecode);
35792 }
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_Py_Void();
35800 if (SWIG_IsTmpObj(res2)) {
35801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35802 } else {
35803 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35805 }
35806 if (SWIG_IsTmpObj(res3)) {
35807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35808 } else {
35809 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35811 }
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 wxPoint *arg2 = 0 ;
35822 wxPoint result;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 wxPoint temp2 ;
35826 PyObject * obj0 = 0 ;
35827 PyObject * obj1 = 0 ;
35828 char * kwnames[] = {
35829 (char *) "self",(char *) "pt", NULL
35830 };
35831
35832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35836 }
35837 arg1 = reinterpret_cast< wxWindow * >(argp1);
35838 {
35839 arg2 = &temp2;
35840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35841 }
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35856 PyObject *resultobj = 0;
35857 wxWindow *arg1 = (wxWindow *) 0 ;
35858 wxPoint *arg2 = 0 ;
35859 wxPoint result;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 wxPoint temp2 ;
35863 PyObject * obj0 = 0 ;
35864 PyObject * obj1 = 0 ;
35865 char * kwnames[] = {
35866 (char *) "self",(char *) "pt", NULL
35867 };
35868
35869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 arg2 = &temp2;
35877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35878 }
35879 {
35880 PyThreadState* __tstate = wxPyBeginAllowThreads();
35881 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35882 wxPyEndAllowThreads(__tstate);
35883 if (PyErr_Occurred()) SWIG_fail;
35884 }
35885 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35886 return resultobj;
35887 fail:
35888 return NULL;
35889 }
35890
35891
35892 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35893 PyObject *resultobj = 0;
35894 wxWindow *arg1 = (wxWindow *) 0 ;
35895 int arg2 ;
35896 int arg3 ;
35897 wxHitTest result;
35898 void *argp1 = 0 ;
35899 int res1 = 0 ;
35900 int val2 ;
35901 int ecode2 = 0 ;
35902 int val3 ;
35903 int ecode3 = 0 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 PyObject * obj2 = 0 ;
35907 char * kwnames[] = {
35908 (char *) "self",(char *) "x",(char *) "y", NULL
35909 };
35910
35911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35913 if (!SWIG_IsOK(res1)) {
35914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35915 }
35916 arg1 = reinterpret_cast< wxWindow * >(argp1);
35917 ecode2 = SWIG_AsVal_int(obj1, &val2);
35918 if (!SWIG_IsOK(ecode2)) {
35919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35920 }
35921 arg2 = static_cast< int >(val2);
35922 ecode3 = SWIG_AsVal_int(obj2, &val3);
35923 if (!SWIG_IsOK(ecode3)) {
35924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35925 }
35926 arg3 = static_cast< int >(val3);
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 resultobj = SWIG_From_int(static_cast< int >(result));
35934 return resultobj;
35935 fail:
35936 return NULL;
35937 }
35938
35939
35940 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35941 PyObject *resultobj = 0;
35942 wxWindow *arg1 = (wxWindow *) 0 ;
35943 wxPoint *arg2 = 0 ;
35944 wxHitTest result;
35945 void *argp1 = 0 ;
35946 int res1 = 0 ;
35947 wxPoint temp2 ;
35948 PyObject * obj0 = 0 ;
35949 PyObject * obj1 = 0 ;
35950 char * kwnames[] = {
35951 (char *) "self",(char *) "pt", NULL
35952 };
35953
35954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35958 }
35959 arg1 = reinterpret_cast< wxWindow * >(argp1);
35960 {
35961 arg2 = &temp2;
35962 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35963 }
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 resultobj = SWIG_From_int(static_cast< int >(result));
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35978 PyObject *resultobj = 0;
35979 wxWindow *arg1 = (wxWindow *) 0 ;
35980 long arg2 ;
35981 wxBorder result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 long val2 ;
35985 int ecode2 = 0 ;
35986
35987 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35994 if (!SWIG_IsOK(ecode2)) {
35995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35996 }
35997 arg2 = static_cast< long >(val2);
35998 {
35999 PyThreadState* __tstate = wxPyBeginAllowThreads();
36000 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 resultobj = SWIG_From_int(static_cast< int >(result));
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 wxBorder result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017
36018 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36022 }
36023 arg1 = reinterpret_cast< wxWindow * >(argp1);
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 resultobj = SWIG_From_int(static_cast< int >(result));
36031 return resultobj;
36032 fail:
36033 return NULL;
36034 }
36035
36036
36037 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36038 int argc;
36039 PyObject *argv[3];
36040
36041 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36042 --argc;
36043 if (argc == 1) {
36044 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36045 }
36046 if (argc == 2) {
36047 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36048 }
36049
36050 fail:
36051 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36052 return NULL;
36053 }
36054
36055
36056 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj = 0;
36058 wxWindow *arg1 = (wxWindow *) 0 ;
36059 long arg2 = (long) wxUPDATE_UI_NONE ;
36060 void *argp1 = 0 ;
36061 int res1 = 0 ;
36062 long val2 ;
36063 int ecode2 = 0 ;
36064 PyObject * obj0 = 0 ;
36065 PyObject * obj1 = 0 ;
36066 char * kwnames[] = {
36067 (char *) "self",(char *) "flags", NULL
36068 };
36069
36070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 if (obj1) {
36077 ecode2 = SWIG_AsVal_long(obj1, &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36080 }
36081 arg2 = static_cast< long >(val2);
36082 }
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 (arg1)->UpdateWindowUI(arg2);
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 resultobj = SWIG_Py_Void();
36090 return resultobj;
36091 fail:
36092 return NULL;
36093 }
36094
36095
36096 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36097 PyObject *resultobj = 0;
36098 wxWindow *arg1 = (wxWindow *) 0 ;
36099 wxMenu *arg2 = (wxMenu *) 0 ;
36100 int arg3 = (int) -1 ;
36101 int arg4 = (int) -1 ;
36102 bool result;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 void *argp2 = 0 ;
36106 int res2 = 0 ;
36107 int val3 ;
36108 int ecode3 = 0 ;
36109 int val4 ;
36110 int ecode4 = 0 ;
36111 PyObject * obj0 = 0 ;
36112 PyObject * obj1 = 0 ;
36113 PyObject * obj2 = 0 ;
36114 PyObject * obj3 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36123 }
36124 arg1 = reinterpret_cast< wxWindow * >(argp1);
36125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36126 if (!SWIG_IsOK(res2)) {
36127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36128 }
36129 arg2 = reinterpret_cast< wxMenu * >(argp2);
36130 if (obj2) {
36131 ecode3 = SWIG_AsVal_int(obj2, &val3);
36132 if (!SWIG_IsOK(ecode3)) {
36133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36134 }
36135 arg3 = static_cast< int >(val3);
36136 }
36137 if (obj3) {
36138 ecode4 = SWIG_AsVal_int(obj3, &val4);
36139 if (!SWIG_IsOK(ecode4)) {
36140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36141 }
36142 arg4 = static_cast< int >(val4);
36143 }
36144 {
36145 PyThreadState* __tstate = wxPyBeginAllowThreads();
36146 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36147 wxPyEndAllowThreads(__tstate);
36148 if (PyErr_Occurred()) SWIG_fail;
36149 }
36150 {
36151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36152 }
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36160 PyObject *resultobj = 0;
36161 wxWindow *arg1 = (wxWindow *) 0 ;
36162 wxMenu *arg2 = (wxMenu *) 0 ;
36163 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36164 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36165 bool result;
36166 void *argp1 = 0 ;
36167 int res1 = 0 ;
36168 void *argp2 = 0 ;
36169 int res2 = 0 ;
36170 wxPoint temp3 ;
36171 PyObject * obj0 = 0 ;
36172 PyObject * obj1 = 0 ;
36173 PyObject * obj2 = 0 ;
36174 char * kwnames[] = {
36175 (char *) "self",(char *) "menu",(char *) "pos", NULL
36176 };
36177
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36185 if (!SWIG_IsOK(res2)) {
36186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36187 }
36188 arg2 = reinterpret_cast< wxMenu * >(argp2);
36189 if (obj2) {
36190 {
36191 arg3 = &temp3;
36192 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36193 }
36194 }
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 {
36202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36203 }
36204 return resultobj;
36205 fail:
36206 return NULL;
36207 }
36208
36209
36210 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36211 PyObject *resultobj = 0;
36212 wxWindow *arg1 = (wxWindow *) 0 ;
36213 bool result;
36214 void *argp1 = 0 ;
36215 int res1 = 0 ;
36216 PyObject *swig_obj[1] ;
36217
36218 if (!args) SWIG_fail;
36219 swig_obj[0] = args;
36220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36221 if (!SWIG_IsOK(res1)) {
36222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36223 }
36224 arg1 = reinterpret_cast< wxWindow * >(argp1);
36225 {
36226 PyThreadState* __tstate = wxPyBeginAllowThreads();
36227 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 {
36232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36233 }
36234 return resultobj;
36235 fail:
36236 return NULL;
36237 }
36238
36239
36240 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36241 PyObject *resultobj = 0;
36242 wxWindow *arg1 = (wxWindow *) 0 ;
36243 long result;
36244 void *argp1 = 0 ;
36245 int res1 = 0 ;
36246 PyObject *swig_obj[1] ;
36247
36248 if (!args) SWIG_fail;
36249 swig_obj[0] = args;
36250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36251 if (!SWIG_IsOK(res1)) {
36252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36253 }
36254 arg1 = reinterpret_cast< wxWindow * >(argp1);
36255 {
36256 PyThreadState* __tstate = wxPyBeginAllowThreads();
36257 result = (long)wxWindow_GetHandle(arg1);
36258 wxPyEndAllowThreads(__tstate);
36259 if (PyErr_Occurred()) SWIG_fail;
36260 }
36261 resultobj = SWIG_From_long(static_cast< long >(result));
36262 return resultobj;
36263 fail:
36264 return NULL;
36265 }
36266
36267
36268 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36269 PyObject *resultobj = 0;
36270 wxWindow *arg1 = (wxWindow *) 0 ;
36271 long arg2 ;
36272 void *argp1 = 0 ;
36273 int res1 = 0 ;
36274 long val2 ;
36275 int ecode2 = 0 ;
36276 PyObject * obj0 = 0 ;
36277 PyObject * obj1 = 0 ;
36278 char * kwnames[] = {
36279 (char *) "self",(char *) "handle", NULL
36280 };
36281
36282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36284 if (!SWIG_IsOK(res1)) {
36285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36286 }
36287 arg1 = reinterpret_cast< wxWindow * >(argp1);
36288 ecode2 = SWIG_AsVal_long(obj1, &val2);
36289 if (!SWIG_IsOK(ecode2)) {
36290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36291 }
36292 arg2 = static_cast< long >(val2);
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 wxWindow_AssociateHandle(arg1,arg2);
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 resultobj = SWIG_Py_Void();
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 PyObject *swig_obj[1] ;
36312
36313 if (!args) SWIG_fail;
36314 swig_obj[0] = args;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 {
36321 PyThreadState* __tstate = wxPyBeginAllowThreads();
36322 (arg1)->DissociateHandle();
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 resultobj = SWIG_Py_Void();
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36334 PyObject *resultobj = 0;
36335 wxWindow *arg1 = (wxWindow *) 0 ;
36336 int arg2 ;
36337 bool result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 int val2 ;
36341 int ecode2 = 0 ;
36342 PyObject * obj0 = 0 ;
36343 PyObject * obj1 = 0 ;
36344 char * kwnames[] = {
36345 (char *) "self",(char *) "orient", NULL
36346 };
36347
36348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36350 if (!SWIG_IsOK(res1)) {
36351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36352 }
36353 arg1 = reinterpret_cast< wxWindow * >(argp1);
36354 ecode2 = SWIG_AsVal_int(obj1, &val2);
36355 if (!SWIG_IsOK(ecode2)) {
36356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36357 }
36358 arg2 = static_cast< int >(val2);
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36362 wxPyEndAllowThreads(__tstate);
36363 if (PyErr_Occurred()) SWIG_fail;
36364 }
36365 {
36366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36367 }
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36375 PyObject *resultobj = 0;
36376 wxWindow *arg1 = (wxWindow *) 0 ;
36377 int arg2 ;
36378 int arg3 ;
36379 int arg4 ;
36380 int arg5 ;
36381 bool arg6 = (bool) true ;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 int val3 ;
36387 int ecode3 = 0 ;
36388 int val4 ;
36389 int ecode4 = 0 ;
36390 int val5 ;
36391 int ecode5 = 0 ;
36392 bool val6 ;
36393 int ecode6 = 0 ;
36394 PyObject * obj0 = 0 ;
36395 PyObject * obj1 = 0 ;
36396 PyObject * obj2 = 0 ;
36397 PyObject * obj3 = 0 ;
36398 PyObject * obj4 = 0 ;
36399 PyObject * obj5 = 0 ;
36400 char * kwnames[] = {
36401 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36402 };
36403
36404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36406 if (!SWIG_IsOK(res1)) {
36407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36408 }
36409 arg1 = reinterpret_cast< wxWindow * >(argp1);
36410 ecode2 = SWIG_AsVal_int(obj1, &val2);
36411 if (!SWIG_IsOK(ecode2)) {
36412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36413 }
36414 arg2 = static_cast< int >(val2);
36415 ecode3 = SWIG_AsVal_int(obj2, &val3);
36416 if (!SWIG_IsOK(ecode3)) {
36417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36418 }
36419 arg3 = static_cast< int >(val3);
36420 ecode4 = SWIG_AsVal_int(obj3, &val4);
36421 if (!SWIG_IsOK(ecode4)) {
36422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36423 }
36424 arg4 = static_cast< int >(val4);
36425 ecode5 = SWIG_AsVal_int(obj4, &val5);
36426 if (!SWIG_IsOK(ecode5)) {
36427 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36428 }
36429 arg5 = static_cast< int >(val5);
36430 if (obj5) {
36431 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36432 if (!SWIG_IsOK(ecode6)) {
36433 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36434 }
36435 arg6 = static_cast< bool >(val6);
36436 }
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 resultobj = SWIG_Py_Void();
36444 return resultobj;
36445 fail:
36446 return NULL;
36447 }
36448
36449
36450 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36451 PyObject *resultobj = 0;
36452 wxWindow *arg1 = (wxWindow *) 0 ;
36453 int arg2 ;
36454 int arg3 ;
36455 bool arg4 = (bool) true ;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 int val2 ;
36459 int ecode2 = 0 ;
36460 int val3 ;
36461 int ecode3 = 0 ;
36462 bool val4 ;
36463 int ecode4 = 0 ;
36464 PyObject * obj0 = 0 ;
36465 PyObject * obj1 = 0 ;
36466 PyObject * obj2 = 0 ;
36467 PyObject * obj3 = 0 ;
36468 char * kwnames[] = {
36469 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36470 };
36471
36472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36474 if (!SWIG_IsOK(res1)) {
36475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36476 }
36477 arg1 = reinterpret_cast< wxWindow * >(argp1);
36478 ecode2 = SWIG_AsVal_int(obj1, &val2);
36479 if (!SWIG_IsOK(ecode2)) {
36480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36481 }
36482 arg2 = static_cast< int >(val2);
36483 ecode3 = SWIG_AsVal_int(obj2, &val3);
36484 if (!SWIG_IsOK(ecode3)) {
36485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36486 }
36487 arg3 = static_cast< int >(val3);
36488 if (obj3) {
36489 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36490 if (!SWIG_IsOK(ecode4)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36492 }
36493 arg4 = static_cast< bool >(val4);
36494 }
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 (arg1)->SetScrollPos(arg2,arg3,arg4);
36498 wxPyEndAllowThreads(__tstate);
36499 if (PyErr_Occurred()) SWIG_fail;
36500 }
36501 resultobj = SWIG_Py_Void();
36502 return resultobj;
36503 fail:
36504 return NULL;
36505 }
36506
36507
36508 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36509 PyObject *resultobj = 0;
36510 wxWindow *arg1 = (wxWindow *) 0 ;
36511 int arg2 ;
36512 int result;
36513 void *argp1 = 0 ;
36514 int res1 = 0 ;
36515 int val2 ;
36516 int ecode2 = 0 ;
36517 PyObject * obj0 = 0 ;
36518 PyObject * obj1 = 0 ;
36519 char * kwnames[] = {
36520 (char *) "self",(char *) "orientation", NULL
36521 };
36522
36523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36525 if (!SWIG_IsOK(res1)) {
36526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36527 }
36528 arg1 = reinterpret_cast< wxWindow * >(argp1);
36529 ecode2 = SWIG_AsVal_int(obj1, &val2);
36530 if (!SWIG_IsOK(ecode2)) {
36531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36532 }
36533 arg2 = static_cast< int >(val2);
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_From_int(static_cast< int >(result));
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 int arg2 ;
36551 int result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 int val2 ;
36555 int ecode2 = 0 ;
36556 PyObject * obj0 = 0 ;
36557 PyObject * obj1 = 0 ;
36558 char * kwnames[] = {
36559 (char *) "self",(char *) "orientation", NULL
36560 };
36561
36562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36564 if (!SWIG_IsOK(res1)) {
36565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36566 }
36567 arg1 = reinterpret_cast< wxWindow * >(argp1);
36568 ecode2 = SWIG_AsVal_int(obj1, &val2);
36569 if (!SWIG_IsOK(ecode2)) {
36570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36571 }
36572 arg2 = static_cast< int >(val2);
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 resultobj = SWIG_From_int(static_cast< int >(result));
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 int arg2 ;
36590 int result;
36591 void *argp1 = 0 ;
36592 int res1 = 0 ;
36593 int val2 ;
36594 int ecode2 = 0 ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char * kwnames[] = {
36598 (char *) "self",(char *) "orientation", NULL
36599 };
36600
36601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36603 if (!SWIG_IsOK(res1)) {
36604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36605 }
36606 arg1 = reinterpret_cast< wxWindow * >(argp1);
36607 ecode2 = SWIG_AsVal_int(obj1, &val2);
36608 if (!SWIG_IsOK(ecode2)) {
36609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36610 }
36611 arg2 = static_cast< int >(val2);
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 resultobj = SWIG_From_int(static_cast< int >(result));
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 int arg2 ;
36629 int arg3 ;
36630 wxRect *arg4 = (wxRect *) NULL ;
36631 void *argp1 = 0 ;
36632 int res1 = 0 ;
36633 int val2 ;
36634 int ecode2 = 0 ;
36635 int val3 ;
36636 int ecode3 = 0 ;
36637 void *argp4 = 0 ;
36638 int res4 = 0 ;
36639 PyObject * obj0 = 0 ;
36640 PyObject * obj1 = 0 ;
36641 PyObject * obj2 = 0 ;
36642 PyObject * obj3 = 0 ;
36643 char * kwnames[] = {
36644 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36645 };
36646
36647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36649 if (!SWIG_IsOK(res1)) {
36650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36651 }
36652 arg1 = reinterpret_cast< wxWindow * >(argp1);
36653 ecode2 = SWIG_AsVal_int(obj1, &val2);
36654 if (!SWIG_IsOK(ecode2)) {
36655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36656 }
36657 arg2 = static_cast< int >(val2);
36658 ecode3 = SWIG_AsVal_int(obj2, &val3);
36659 if (!SWIG_IsOK(ecode3)) {
36660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36661 }
36662 arg3 = static_cast< int >(val3);
36663 if (obj3) {
36664 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36665 if (!SWIG_IsOK(res4)) {
36666 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36667 }
36668 arg4 = reinterpret_cast< wxRect * >(argp4);
36669 }
36670 {
36671 PyThreadState* __tstate = wxPyBeginAllowThreads();
36672 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 resultobj = SWIG_Py_Void();
36677 return resultobj;
36678 fail:
36679 return NULL;
36680 }
36681
36682
36683 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj = 0;
36685 wxWindow *arg1 = (wxWindow *) 0 ;
36686 int arg2 ;
36687 bool result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 int val2 ;
36691 int ecode2 = 0 ;
36692 PyObject * obj0 = 0 ;
36693 PyObject * obj1 = 0 ;
36694 char * kwnames[] = {
36695 (char *) "self",(char *) "lines", NULL
36696 };
36697
36698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36700 if (!SWIG_IsOK(res1)) {
36701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36702 }
36703 arg1 = reinterpret_cast< wxWindow * >(argp1);
36704 ecode2 = SWIG_AsVal_int(obj1, &val2);
36705 if (!SWIG_IsOK(ecode2)) {
36706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36707 }
36708 arg2 = static_cast< int >(val2);
36709 {
36710 PyThreadState* __tstate = wxPyBeginAllowThreads();
36711 result = (bool)(arg1)->ScrollLines(arg2);
36712 wxPyEndAllowThreads(__tstate);
36713 if (PyErr_Occurred()) SWIG_fail;
36714 }
36715 {
36716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36717 }
36718 return resultobj;
36719 fail:
36720 return NULL;
36721 }
36722
36723
36724 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36725 PyObject *resultobj = 0;
36726 wxWindow *arg1 = (wxWindow *) 0 ;
36727 int arg2 ;
36728 bool result;
36729 void *argp1 = 0 ;
36730 int res1 = 0 ;
36731 int val2 ;
36732 int ecode2 = 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char * kwnames[] = {
36736 (char *) "self",(char *) "pages", NULL
36737 };
36738
36739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36741 if (!SWIG_IsOK(res1)) {
36742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36743 }
36744 arg1 = reinterpret_cast< wxWindow * >(argp1);
36745 ecode2 = SWIG_AsVal_int(obj1, &val2);
36746 if (!SWIG_IsOK(ecode2)) {
36747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36748 }
36749 arg2 = static_cast< int >(val2);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = (bool)(arg1)->ScrollPages(arg2);
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 {
36757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36758 }
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36766 PyObject *resultobj = 0;
36767 wxWindow *arg1 = (wxWindow *) 0 ;
36768 bool result;
36769 void *argp1 = 0 ;
36770 int res1 = 0 ;
36771 PyObject *swig_obj[1] ;
36772
36773 if (!args) SWIG_fail;
36774 swig_obj[0] = args;
36775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36776 if (!SWIG_IsOK(res1)) {
36777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36778 }
36779 arg1 = reinterpret_cast< wxWindow * >(argp1);
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 result = (bool)(arg1)->LineUp();
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 {
36787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36788 }
36789 return resultobj;
36790 fail:
36791 return NULL;
36792 }
36793
36794
36795 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36796 PyObject *resultobj = 0;
36797 wxWindow *arg1 = (wxWindow *) 0 ;
36798 bool result;
36799 void *argp1 = 0 ;
36800 int res1 = 0 ;
36801 PyObject *swig_obj[1] ;
36802
36803 if (!args) SWIG_fail;
36804 swig_obj[0] = args;
36805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36806 if (!SWIG_IsOK(res1)) {
36807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36808 }
36809 arg1 = reinterpret_cast< wxWindow * >(argp1);
36810 {
36811 PyThreadState* __tstate = wxPyBeginAllowThreads();
36812 result = (bool)(arg1)->LineDown();
36813 wxPyEndAllowThreads(__tstate);
36814 if (PyErr_Occurred()) SWIG_fail;
36815 }
36816 {
36817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36818 }
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36826 PyObject *resultobj = 0;
36827 wxWindow *arg1 = (wxWindow *) 0 ;
36828 bool result;
36829 void *argp1 = 0 ;
36830 int res1 = 0 ;
36831 PyObject *swig_obj[1] ;
36832
36833 if (!args) SWIG_fail;
36834 swig_obj[0] = args;
36835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36836 if (!SWIG_IsOK(res1)) {
36837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36838 }
36839 arg1 = reinterpret_cast< wxWindow * >(argp1);
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = (bool)(arg1)->PageUp();
36843 wxPyEndAllowThreads(__tstate);
36844 if (PyErr_Occurred()) SWIG_fail;
36845 }
36846 {
36847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36848 }
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36856 PyObject *resultobj = 0;
36857 wxWindow *arg1 = (wxWindow *) 0 ;
36858 bool result;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 PyObject *swig_obj[1] ;
36862
36863 if (!args) SWIG_fail;
36864 swig_obj[0] = args;
36865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36866 if (!SWIG_IsOK(res1)) {
36867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36868 }
36869 arg1 = reinterpret_cast< wxWindow * >(argp1);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = (bool)(arg1)->PageDown();
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj = 0;
36887 wxWindow *arg1 = (wxWindow *) 0 ;
36888 wxString *arg2 = 0 ;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 bool temp2 = false ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char * kwnames[] = {
36895 (char *) "self",(char *) "text", NULL
36896 };
36897
36898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36902 }
36903 arg1 = reinterpret_cast< wxWindow * >(argp1);
36904 {
36905 arg2 = wxString_in_helper(obj1);
36906 if (arg2 == NULL) SWIG_fail;
36907 temp2 = true;
36908 }
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 (arg1)->SetHelpText((wxString const &)*arg2);
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 resultobj = SWIG_Py_Void();
36916 {
36917 if (temp2)
36918 delete arg2;
36919 }
36920 return resultobj;
36921 fail:
36922 {
36923 if (temp2)
36924 delete arg2;
36925 }
36926 return NULL;
36927 }
36928
36929
36930 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36931 PyObject *resultobj = 0;
36932 wxWindow *arg1 = (wxWindow *) 0 ;
36933 wxString *arg2 = 0 ;
36934 void *argp1 = 0 ;
36935 int res1 = 0 ;
36936 bool temp2 = false ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 char * kwnames[] = {
36940 (char *) "self",(char *) "text", NULL
36941 };
36942
36943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36945 if (!SWIG_IsOK(res1)) {
36946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36947 }
36948 arg1 = reinterpret_cast< wxWindow * >(argp1);
36949 {
36950 arg2 = wxString_in_helper(obj1);
36951 if (arg2 == NULL) SWIG_fail;
36952 temp2 = true;
36953 }
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 resultobj = SWIG_Py_Void();
36961 {
36962 if (temp2)
36963 delete arg2;
36964 }
36965 return resultobj;
36966 fail:
36967 {
36968 if (temp2)
36969 delete arg2;
36970 }
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36976 PyObject *resultobj = 0;
36977 wxWindow *arg1 = (wxWindow *) 0 ;
36978 wxPoint *arg2 = 0 ;
36979 wxHelpEvent::Origin arg3 ;
36980 wxString result;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 wxPoint temp2 ;
36984 void *argp3 ;
36985 int res3 = 0 ;
36986 PyObject * obj0 = 0 ;
36987 PyObject * obj1 = 0 ;
36988 PyObject * obj2 = 0 ;
36989 char * kwnames[] = {
36990 (char *) "self",(char *) "pt",(char *) "origin", NULL
36991 };
36992
36993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36995 if (!SWIG_IsOK(res1)) {
36996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36997 }
36998 arg1 = reinterpret_cast< wxWindow * >(argp1);
36999 {
37000 arg2 = &temp2;
37001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37002 }
37003 {
37004 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37005 if (!SWIG_IsOK(res3)) {
37006 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37007 }
37008 if (!argp3) {
37009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37010 } else {
37011 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37012 arg3 = *temp;
37013 if (SWIG_IsNewObj(res3)) delete temp;
37014 }
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 {
37023 #if wxUSE_UNICODE
37024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37025 #else
37026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37027 #endif
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 wxString result;
37039 void *argp1 = 0 ;
37040 int res1 = 0 ;
37041 PyObject *swig_obj[1] ;
37042
37043 if (!args) SWIG_fail;
37044 swig_obj[0] = args;
37045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37046 if (!SWIG_IsOK(res1)) {
37047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37048 }
37049 arg1 = reinterpret_cast< wxWindow * >(argp1);
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 result = ((wxWindow const *)arg1)->GetHelpText();
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 {
37057 #if wxUSE_UNICODE
37058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37059 #else
37060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37061 #endif
37062 }
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj = 0;
37071 wxWindow *arg1 = (wxWindow *) 0 ;
37072 wxString *arg2 = 0 ;
37073 void *argp1 = 0 ;
37074 int res1 = 0 ;
37075 bool temp2 = false ;
37076 PyObject * obj0 = 0 ;
37077 PyObject * obj1 = 0 ;
37078 char * kwnames[] = {
37079 (char *) "self",(char *) "tip", NULL
37080 };
37081
37082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37084 if (!SWIG_IsOK(res1)) {
37085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37086 }
37087 arg1 = reinterpret_cast< wxWindow * >(argp1);
37088 {
37089 arg2 = wxString_in_helper(obj1);
37090 if (arg2 == NULL) SWIG_fail;
37091 temp2 = true;
37092 }
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->SetToolTip((wxString const &)*arg2);
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 resultobj = SWIG_Py_Void();
37100 {
37101 if (temp2)
37102 delete arg2;
37103 }
37104 return resultobj;
37105 fail:
37106 {
37107 if (temp2)
37108 delete arg2;
37109 }
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 wxToolTip *arg2 = (wxToolTip *) 0 ;
37118 void *argp1 = 0 ;
37119 int res1 = 0 ;
37120 int res2 = 0 ;
37121 PyObject * obj0 = 0 ;
37122 PyObject * obj1 = 0 ;
37123 char * kwnames[] = {
37124 (char *) "self",(char *) "tip", NULL
37125 };
37126
37127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37129 if (!SWIG_IsOK(res1)) {
37130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37131 }
37132 arg1 = reinterpret_cast< wxWindow * >(argp1);
37133 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37134 if (!SWIG_IsOK(res2)) {
37135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37136 }
37137 {
37138 PyThreadState* __tstate = wxPyBeginAllowThreads();
37139 (arg1)->SetToolTip(arg2);
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 resultobj = SWIG_Py_Void();
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37151 PyObject *resultobj = 0;
37152 wxWindow *arg1 = (wxWindow *) 0 ;
37153 wxToolTip *result = 0 ;
37154 void *argp1 = 0 ;
37155 int res1 = 0 ;
37156 PyObject *swig_obj[1] ;
37157
37158 if (!args) SWIG_fail;
37159 swig_obj[0] = args;
37160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37161 if (!SWIG_IsOK(res1)) {
37162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37163 }
37164 arg1 = reinterpret_cast< wxWindow * >(argp1);
37165 {
37166 PyThreadState* __tstate = wxPyBeginAllowThreads();
37167 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37168 wxPyEndAllowThreads(__tstate);
37169 if (PyErr_Occurred()) SWIG_fail;
37170 }
37171 {
37172 resultobj = wxPyMake_wxObject(result, (bool)0);
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj = 0;
37182 wxWindow *arg1 = (wxWindow *) 0 ;
37183 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37184 void *argp1 = 0 ;
37185 int res1 = 0 ;
37186 int res2 = 0 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 char * kwnames[] = {
37190 (char *) "self",(char *) "dropTarget", NULL
37191 };
37192
37193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37195 if (!SWIG_IsOK(res1)) {
37196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37197 }
37198 arg1 = reinterpret_cast< wxWindow * >(argp1);
37199 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37200 if (!SWIG_IsOK(res2)) {
37201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37202 }
37203 {
37204 PyThreadState* __tstate = wxPyBeginAllowThreads();
37205 (arg1)->SetDropTarget(arg2);
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 resultobj = SWIG_Py_Void();
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37217 PyObject *resultobj = 0;
37218 wxWindow *arg1 = (wxWindow *) 0 ;
37219 wxPyDropTarget *result = 0 ;
37220 void *argp1 = 0 ;
37221 int res1 = 0 ;
37222 PyObject *swig_obj[1] ;
37223
37224 if (!args) SWIG_fail;
37225 swig_obj[0] = args;
37226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37227 if (!SWIG_IsOK(res1)) {
37228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37229 }
37230 arg1 = reinterpret_cast< wxWindow * >(argp1);
37231 {
37232 PyThreadState* __tstate = wxPyBeginAllowThreads();
37233 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37234 wxPyEndAllowThreads(__tstate);
37235 if (PyErr_Occurred()) SWIG_fail;
37236 }
37237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37238 return resultobj;
37239 fail:
37240 return NULL;
37241 }
37242
37243
37244 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37245 PyObject *resultobj = 0;
37246 wxWindow *arg1 = (wxWindow *) 0 ;
37247 bool arg2 ;
37248 void *argp1 = 0 ;
37249 int res1 = 0 ;
37250 bool val2 ;
37251 int ecode2 = 0 ;
37252 PyObject * obj0 = 0 ;
37253 PyObject * obj1 = 0 ;
37254 char * kwnames[] = {
37255 (char *) "self",(char *) "accept", NULL
37256 };
37257
37258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37260 if (!SWIG_IsOK(res1)) {
37261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37262 }
37263 arg1 = reinterpret_cast< wxWindow * >(argp1);
37264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37265 if (!SWIG_IsOK(ecode2)) {
37266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37267 }
37268 arg2 = static_cast< bool >(val2);
37269 {
37270 PyThreadState* __tstate = wxPyBeginAllowThreads();
37271 wxWindow_DragAcceptFiles(arg1,arg2);
37272 wxPyEndAllowThreads(__tstate);
37273 if (PyErr_Occurred()) SWIG_fail;
37274 }
37275 resultobj = SWIG_Py_Void();
37276 return resultobj;
37277 fail:
37278 return NULL;
37279 }
37280
37281
37282 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj = 0;
37284 wxWindow *arg1 = (wxWindow *) 0 ;
37285 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37286 void *argp1 = 0 ;
37287 int res1 = 0 ;
37288 int res2 = 0 ;
37289 PyObject * obj0 = 0 ;
37290 PyObject * obj1 = 0 ;
37291 char * kwnames[] = {
37292 (char *) "self",(char *) "constraints", NULL
37293 };
37294
37295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37297 if (!SWIG_IsOK(res1)) {
37298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37299 }
37300 arg1 = reinterpret_cast< wxWindow * >(argp1);
37301 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37302 if (!SWIG_IsOK(res2)) {
37303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37304 }
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 (arg1)->SetConstraints(arg2);
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 resultobj = SWIG_Py_Void();
37312 return resultobj;
37313 fail:
37314 return NULL;
37315 }
37316
37317
37318 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37319 PyObject *resultobj = 0;
37320 wxWindow *arg1 = (wxWindow *) 0 ;
37321 wxLayoutConstraints *result = 0 ;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 PyObject *swig_obj[1] ;
37325
37326 if (!args) SWIG_fail;
37327 swig_obj[0] = args;
37328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37329 if (!SWIG_IsOK(res1)) {
37330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37331 }
37332 arg1 = reinterpret_cast< wxWindow * >(argp1);
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37336 wxPyEndAllowThreads(__tstate);
37337 if (PyErr_Occurred()) SWIG_fail;
37338 }
37339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37340 return resultobj;
37341 fail:
37342 return NULL;
37343 }
37344
37345
37346 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37347 PyObject *resultobj = 0;
37348 wxWindow *arg1 = (wxWindow *) 0 ;
37349 bool arg2 ;
37350 void *argp1 = 0 ;
37351 int res1 = 0 ;
37352 bool val2 ;
37353 int ecode2 = 0 ;
37354 PyObject * obj0 = 0 ;
37355 PyObject * obj1 = 0 ;
37356 char * kwnames[] = {
37357 (char *) "self",(char *) "autoLayout", NULL
37358 };
37359
37360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37367 if (!SWIG_IsOK(ecode2)) {
37368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37369 }
37370 arg2 = static_cast< bool >(val2);
37371 {
37372 PyThreadState* __tstate = wxPyBeginAllowThreads();
37373 (arg1)->SetAutoLayout(arg2);
37374 wxPyEndAllowThreads(__tstate);
37375 if (PyErr_Occurred()) SWIG_fail;
37376 }
37377 resultobj = SWIG_Py_Void();
37378 return resultobj;
37379 fail:
37380 return NULL;
37381 }
37382
37383
37384 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37385 PyObject *resultobj = 0;
37386 wxWindow *arg1 = (wxWindow *) 0 ;
37387 bool result;
37388 void *argp1 = 0 ;
37389 int res1 = 0 ;
37390 PyObject *swig_obj[1] ;
37391
37392 if (!args) SWIG_fail;
37393 swig_obj[0] = args;
37394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37395 if (!SWIG_IsOK(res1)) {
37396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37397 }
37398 arg1 = reinterpret_cast< wxWindow * >(argp1);
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 {
37406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37407 }
37408 return resultobj;
37409 fail:
37410 return NULL;
37411 }
37412
37413
37414 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37415 PyObject *resultobj = 0;
37416 wxWindow *arg1 = (wxWindow *) 0 ;
37417 bool result;
37418 void *argp1 = 0 ;
37419 int res1 = 0 ;
37420 PyObject *swig_obj[1] ;
37421
37422 if (!args) SWIG_fail;
37423 swig_obj[0] = args;
37424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37425 if (!SWIG_IsOK(res1)) {
37426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37427 }
37428 arg1 = reinterpret_cast< wxWindow * >(argp1);
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 result = (bool)(arg1)->Layout();
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 {
37436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37437 }
37438 return resultobj;
37439 fail:
37440 return NULL;
37441 }
37442
37443
37444 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37445 PyObject *resultobj = 0;
37446 wxWindow *arg1 = (wxWindow *) 0 ;
37447 wxSizer *arg2 = (wxSizer *) 0 ;
37448 bool arg3 = (bool) true ;
37449 void *argp1 = 0 ;
37450 int res1 = 0 ;
37451 int res2 = 0 ;
37452 bool val3 ;
37453 int ecode3 = 0 ;
37454 PyObject * obj0 = 0 ;
37455 PyObject * obj1 = 0 ;
37456 PyObject * obj2 = 0 ;
37457 char * kwnames[] = {
37458 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37459 };
37460
37461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37463 if (!SWIG_IsOK(res1)) {
37464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37465 }
37466 arg1 = reinterpret_cast< wxWindow * >(argp1);
37467 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37468 if (!SWIG_IsOK(res2)) {
37469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37470 }
37471 if (obj2) {
37472 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37473 if (!SWIG_IsOK(ecode3)) {
37474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37475 }
37476 arg3 = static_cast< bool >(val3);
37477 }
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 (arg1)->SetSizer(arg2,arg3);
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 resultobj = SWIG_Py_Void();
37485 return resultobj;
37486 fail:
37487 return NULL;
37488 }
37489
37490
37491 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37492 PyObject *resultobj = 0;
37493 wxWindow *arg1 = (wxWindow *) 0 ;
37494 wxSizer *arg2 = (wxSizer *) 0 ;
37495 bool arg3 = (bool) true ;
37496 void *argp1 = 0 ;
37497 int res1 = 0 ;
37498 int res2 = 0 ;
37499 bool val3 ;
37500 int ecode3 = 0 ;
37501 PyObject * obj0 = 0 ;
37502 PyObject * obj1 = 0 ;
37503 PyObject * obj2 = 0 ;
37504 char * kwnames[] = {
37505 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37506 };
37507
37508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37515 if (!SWIG_IsOK(res2)) {
37516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37517 }
37518 if (obj2) {
37519 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37520 if (!SWIG_IsOK(ecode3)) {
37521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37522 }
37523 arg3 = static_cast< bool >(val3);
37524 }
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 (arg1)->SetSizerAndFit(arg2,arg3);
37528 wxPyEndAllowThreads(__tstate);
37529 if (PyErr_Occurred()) SWIG_fail;
37530 }
37531 resultobj = SWIG_Py_Void();
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 wxSizer *result = 0 ;
37542 void *argp1 = 0 ;
37543 int res1 = 0 ;
37544 PyObject *swig_obj[1] ;
37545
37546 if (!args) SWIG_fail;
37547 swig_obj[0] = args;
37548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = wxPyMake_wxObject(result, (bool)0);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 wxSizer *arg2 = (wxSizer *) 0 ;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 void *argp2 = 0 ;
37575 int res2 = 0 ;
37576 PyObject * obj0 = 0 ;
37577 PyObject * obj1 = 0 ;
37578 char * kwnames[] = {
37579 (char *) "self",(char *) "sizer", NULL
37580 };
37581
37582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37584 if (!SWIG_IsOK(res1)) {
37585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37586 }
37587 arg1 = reinterpret_cast< wxWindow * >(argp1);
37588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37589 if (!SWIG_IsOK(res2)) {
37590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37591 }
37592 arg2 = reinterpret_cast< wxSizer * >(argp2);
37593 {
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 (arg1)->SetContainingSizer(arg2);
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 resultobj = SWIG_Py_Void();
37600 return resultobj;
37601 fail:
37602 return NULL;
37603 }
37604
37605
37606 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37607 PyObject *resultobj = 0;
37608 wxWindow *arg1 = (wxWindow *) 0 ;
37609 wxSizer *result = 0 ;
37610 void *argp1 = 0 ;
37611 int res1 = 0 ;
37612 PyObject *swig_obj[1] ;
37613
37614 if (!args) SWIG_fail;
37615 swig_obj[0] = args;
37616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37617 if (!SWIG_IsOK(res1)) {
37618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37619 }
37620 arg1 = reinterpret_cast< wxWindow * >(argp1);
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 {
37628 resultobj = wxPyMake_wxObject(result, (bool)0);
37629 }
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37637 PyObject *resultobj = 0;
37638 wxWindow *arg1 = (wxWindow *) 0 ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 PyObject *swig_obj[1] ;
37642
37643 if (!args) SWIG_fail;
37644 swig_obj[0] = args;
37645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37646 if (!SWIG_IsOK(res1)) {
37647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37648 }
37649 arg1 = reinterpret_cast< wxWindow * >(argp1);
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 (arg1)->InheritAttributes();
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 resultobj = SWIG_Py_Void();
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37664 PyObject *resultobj = 0;
37665 wxWindow *arg1 = (wxWindow *) 0 ;
37666 bool result;
37667 void *argp1 = 0 ;
37668 int res1 = 0 ;
37669 PyObject *swig_obj[1] ;
37670
37671 if (!args) SWIG_fail;
37672 swig_obj[0] = args;
37673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37674 if (!SWIG_IsOK(res1)) {
37675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37676 }
37677 arg1 = reinterpret_cast< wxWindow * >(argp1);
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 {
37685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37686 }
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *obj;
37695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37696 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37697 return SWIG_Py_Void();
37698 }
37699
37700 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37701 return SWIG_Python_InitShadowInstance(args);
37702 }
37703
37704 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = 0;
37706 long arg1 ;
37707 wxWindow *arg2 = (wxWindow *) NULL ;
37708 wxWindow *result = 0 ;
37709 long val1 ;
37710 int ecode1 = 0 ;
37711 void *argp2 = 0 ;
37712 int res2 = 0 ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "id",(char *) "parent", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37720 ecode1 = SWIG_AsVal_long(obj0, &val1);
37721 if (!SWIG_IsOK(ecode1)) {
37722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37723 }
37724 arg1 = static_cast< long >(val1);
37725 if (obj1) {
37726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37727 if (!SWIG_IsOK(res2)) {
37728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37729 }
37730 arg2 = reinterpret_cast< wxWindow * >(argp2);
37731 }
37732 {
37733 if (!wxPyCheckForApp()) SWIG_fail;
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37736 wxPyEndAllowThreads(__tstate);
37737 if (PyErr_Occurred()) SWIG_fail;
37738 }
37739 {
37740 resultobj = wxPyMake_wxObject(result, 0);
37741 }
37742 return resultobj;
37743 fail:
37744 return NULL;
37745 }
37746
37747
37748 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37749 PyObject *resultobj = 0;
37750 wxString *arg1 = 0 ;
37751 wxWindow *arg2 = (wxWindow *) NULL ;
37752 wxWindow *result = 0 ;
37753 bool temp1 = false ;
37754 void *argp2 = 0 ;
37755 int res2 = 0 ;
37756 PyObject * obj0 = 0 ;
37757 PyObject * obj1 = 0 ;
37758 char * kwnames[] = {
37759 (char *) "name",(char *) "parent", NULL
37760 };
37761
37762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37763 {
37764 arg1 = wxString_in_helper(obj0);
37765 if (arg1 == NULL) SWIG_fail;
37766 temp1 = true;
37767 }
37768 if (obj1) {
37769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37770 if (!SWIG_IsOK(res2)) {
37771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37772 }
37773 arg2 = reinterpret_cast< wxWindow * >(argp2);
37774 }
37775 {
37776 if (!wxPyCheckForApp()) SWIG_fail;
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = wxPyMake_wxObject(result, 0);
37784 }
37785 {
37786 if (temp1)
37787 delete arg1;
37788 }
37789 return resultobj;
37790 fail:
37791 {
37792 if (temp1)
37793 delete arg1;
37794 }
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj = 0;
37801 wxString *arg1 = 0 ;
37802 wxWindow *arg2 = (wxWindow *) NULL ;
37803 wxWindow *result = 0 ;
37804 bool temp1 = false ;
37805 void *argp2 = 0 ;
37806 int res2 = 0 ;
37807 PyObject * obj0 = 0 ;
37808 PyObject * obj1 = 0 ;
37809 char * kwnames[] = {
37810 (char *) "label",(char *) "parent", NULL
37811 };
37812
37813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37814 {
37815 arg1 = wxString_in_helper(obj0);
37816 if (arg1 == NULL) SWIG_fail;
37817 temp1 = true;
37818 }
37819 if (obj1) {
37820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37821 if (!SWIG_IsOK(res2)) {
37822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37823 }
37824 arg2 = reinterpret_cast< wxWindow * >(argp2);
37825 }
37826 {
37827 if (!wxPyCheckForApp()) SWIG_fail;
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 {
37834 resultobj = wxPyMake_wxObject(result, 0);
37835 }
37836 {
37837 if (temp1)
37838 delete arg1;
37839 }
37840 return resultobj;
37841 fail:
37842 {
37843 if (temp1)
37844 delete arg1;
37845 }
37846 return NULL;
37847 }
37848
37849
37850 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37851 PyObject *resultobj = 0;
37852 wxWindow *arg1 = (wxWindow *) 0 ;
37853 unsigned long arg2 ;
37854 wxWindow *result = 0 ;
37855 void *argp1 = 0 ;
37856 int res1 = 0 ;
37857 unsigned long val2 ;
37858 int ecode2 = 0 ;
37859 PyObject * obj0 = 0 ;
37860 PyObject * obj1 = 0 ;
37861 char * kwnames[] = {
37862 (char *) "parent",(char *) "_hWnd", NULL
37863 };
37864
37865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37867 if (!SWIG_IsOK(res1)) {
37868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37869 }
37870 arg1 = reinterpret_cast< wxWindow * >(argp1);
37871 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37872 if (!SWIG_IsOK(ecode2)) {
37873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37874 }
37875 arg2 = static_cast< unsigned long >(val2);
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 resultobj = wxPyMake_wxObject(result, 0);
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 PyObject *result = 0 ;
37894
37895 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37896 {
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (PyObject *)GetTopLevelWindows();
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = result;
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37910 PyObject *resultobj = 0;
37911 wxValidator *result = 0 ;
37912
37913 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37914 {
37915 PyThreadState* __tstate = wxPyBeginAllowThreads();
37916 result = (wxValidator *)new wxValidator();
37917 wxPyEndAllowThreads(__tstate);
37918 if (PyErr_Occurred()) SWIG_fail;
37919 }
37920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37928 PyObject *resultobj = 0;
37929 wxValidator *arg1 = (wxValidator *) 0 ;
37930 wxValidator *result = 0 ;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 PyObject *swig_obj[1] ;
37934
37935 if (!args) SWIG_fail;
37936 swig_obj[0] = args;
37937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37938 if (!SWIG_IsOK(res1)) {
37939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37940 }
37941 arg1 = reinterpret_cast< wxValidator * >(argp1);
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 result = (wxValidator *)(arg1)->Clone();
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 {
37949 resultobj = wxPyMake_wxObject(result, 0);
37950 }
37951 return resultobj;
37952 fail:
37953 return NULL;
37954 }
37955
37956
37957 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37958 PyObject *resultobj = 0;
37959 wxValidator *arg1 = (wxValidator *) 0 ;
37960 wxWindow *arg2 = (wxWindow *) 0 ;
37961 bool result;
37962 void *argp1 = 0 ;
37963 int res1 = 0 ;
37964 void *argp2 = 0 ;
37965 int res2 = 0 ;
37966 PyObject * obj0 = 0 ;
37967 PyObject * obj1 = 0 ;
37968 char * kwnames[] = {
37969 (char *) "self",(char *) "parent", NULL
37970 };
37971
37972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37974 if (!SWIG_IsOK(res1)) {
37975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37976 }
37977 arg1 = reinterpret_cast< wxValidator * >(argp1);
37978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37979 if (!SWIG_IsOK(res2)) {
37980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37981 }
37982 arg2 = reinterpret_cast< wxWindow * >(argp2);
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 result = (bool)(arg1)->Validate(arg2);
37986 wxPyEndAllowThreads(__tstate);
37987 if (PyErr_Occurred()) SWIG_fail;
37988 }
37989 {
37990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37991 }
37992 return resultobj;
37993 fail:
37994 return NULL;
37995 }
37996
37997
37998 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37999 PyObject *resultobj = 0;
38000 wxValidator *arg1 = (wxValidator *) 0 ;
38001 bool result;
38002 void *argp1 = 0 ;
38003 int res1 = 0 ;
38004 PyObject *swig_obj[1] ;
38005
38006 if (!args) SWIG_fail;
38007 swig_obj[0] = args;
38008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38009 if (!SWIG_IsOK(res1)) {
38010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38011 }
38012 arg1 = reinterpret_cast< wxValidator * >(argp1);
38013 {
38014 PyThreadState* __tstate = wxPyBeginAllowThreads();
38015 result = (bool)(arg1)->TransferToWindow();
38016 wxPyEndAllowThreads(__tstate);
38017 if (PyErr_Occurred()) SWIG_fail;
38018 }
38019 {
38020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38021 }
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38029 PyObject *resultobj = 0;
38030 wxValidator *arg1 = (wxValidator *) 0 ;
38031 bool result;
38032 void *argp1 = 0 ;
38033 int res1 = 0 ;
38034 PyObject *swig_obj[1] ;
38035
38036 if (!args) SWIG_fail;
38037 swig_obj[0] = args;
38038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38041 }
38042 arg1 = reinterpret_cast< wxValidator * >(argp1);
38043 {
38044 PyThreadState* __tstate = wxPyBeginAllowThreads();
38045 result = (bool)(arg1)->TransferFromWindow();
38046 wxPyEndAllowThreads(__tstate);
38047 if (PyErr_Occurred()) SWIG_fail;
38048 }
38049 {
38050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38051 }
38052 return resultobj;
38053 fail:
38054 return NULL;
38055 }
38056
38057
38058 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38059 PyObject *resultobj = 0;
38060 wxValidator *arg1 = (wxValidator *) 0 ;
38061 wxWindow *result = 0 ;
38062 void *argp1 = 0 ;
38063 int res1 = 0 ;
38064 PyObject *swig_obj[1] ;
38065
38066 if (!args) SWIG_fail;
38067 swig_obj[0] = args;
38068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38069 if (!SWIG_IsOK(res1)) {
38070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38071 }
38072 arg1 = reinterpret_cast< wxValidator * >(argp1);
38073 {
38074 PyThreadState* __tstate = wxPyBeginAllowThreads();
38075 result = (wxWindow *)(arg1)->GetWindow();
38076 wxPyEndAllowThreads(__tstate);
38077 if (PyErr_Occurred()) SWIG_fail;
38078 }
38079 {
38080 resultobj = wxPyMake_wxObject(result, 0);
38081 }
38082 return resultobj;
38083 fail:
38084 return NULL;
38085 }
38086
38087
38088 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38089 PyObject *resultobj = 0;
38090 wxValidator *arg1 = (wxValidator *) 0 ;
38091 wxWindow *arg2 = (wxWindow *) 0 ;
38092 void *argp1 = 0 ;
38093 int res1 = 0 ;
38094 void *argp2 = 0 ;
38095 int res2 = 0 ;
38096 PyObject * obj0 = 0 ;
38097 PyObject * obj1 = 0 ;
38098 char * kwnames[] = {
38099 (char *) "self",(char *) "window", NULL
38100 };
38101
38102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38104 if (!SWIG_IsOK(res1)) {
38105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38106 }
38107 arg1 = reinterpret_cast< wxValidator * >(argp1);
38108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res2)) {
38110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38111 }
38112 arg2 = reinterpret_cast< wxWindow * >(argp2);
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 (arg1)->SetWindow(arg2);
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 resultobj = SWIG_Py_Void();
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38127 PyObject *resultobj = 0;
38128 bool result;
38129
38130 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 result = (bool)wxValidator::IsSilent();
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj = 0;
38148 int arg1 = (int) true ;
38149 int val1 ;
38150 int ecode1 = 0 ;
38151 PyObject * obj0 = 0 ;
38152 char * kwnames[] = {
38153 (char *) "doIt", NULL
38154 };
38155
38156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38157 if (obj0) {
38158 ecode1 = SWIG_AsVal_int(obj0, &val1);
38159 if (!SWIG_IsOK(ecode1)) {
38160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38161 }
38162 arg1 = static_cast< int >(val1);
38163 }
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 wxValidator::SetBellOnError(arg1);
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 resultobj = SWIG_Py_Void();
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38178 PyObject *obj;
38179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38180 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38181 return SWIG_Py_Void();
38182 }
38183
38184 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38185 return SWIG_Python_InitShadowInstance(args);
38186 }
38187
38188 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38189 PyObject *resultobj = 0;
38190 wxPyValidator *result = 0 ;
38191
38192 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38193 {
38194 PyThreadState* __tstate = wxPyBeginAllowThreads();
38195 result = (wxPyValidator *)new wxPyValidator();
38196 wxPyEndAllowThreads(__tstate);
38197 if (PyErr_Occurred()) SWIG_fail;
38198 }
38199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38200 return resultobj;
38201 fail:
38202 return NULL;
38203 }
38204
38205
38206 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38207 PyObject *resultobj = 0;
38208 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38209 PyObject *arg2 = (PyObject *) 0 ;
38210 PyObject *arg3 = (PyObject *) 0 ;
38211 int arg4 = (int) true ;
38212 void *argp1 = 0 ;
38213 int res1 = 0 ;
38214 int val4 ;
38215 int ecode4 = 0 ;
38216 PyObject * obj0 = 0 ;
38217 PyObject * obj1 = 0 ;
38218 PyObject * obj2 = 0 ;
38219 PyObject * obj3 = 0 ;
38220 char * kwnames[] = {
38221 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38222 };
38223
38224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38226 if (!SWIG_IsOK(res1)) {
38227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38228 }
38229 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38230 arg2 = obj1;
38231 arg3 = obj2;
38232 if (obj3) {
38233 ecode4 = SWIG_AsVal_int(obj3, &val4);
38234 if (!SWIG_IsOK(ecode4)) {
38235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38236 }
38237 arg4 = static_cast< int >(val4);
38238 }
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38242 wxPyEndAllowThreads(__tstate);
38243 if (PyErr_Occurred()) SWIG_fail;
38244 }
38245 resultobj = SWIG_Py_Void();
38246 return resultobj;
38247 fail:
38248 return NULL;
38249 }
38250
38251
38252 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38253 PyObject *obj;
38254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38255 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38256 return SWIG_Py_Void();
38257 }
38258
38259 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38260 return SWIG_Python_InitShadowInstance(args);
38261 }
38262
38263 SWIGINTERN int DefaultValidator_set(PyObject *) {
38264 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38265 return 1;
38266 }
38267
38268
38269 SWIGINTERN PyObject *DefaultValidator_get(void) {
38270 PyObject *pyobj = 0;
38271
38272 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38273 return pyobj;
38274 }
38275
38276
38277 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38278 PyObject *resultobj = 0;
38279 wxString const &arg1_defvalue = wxPyEmptyString ;
38280 wxString *arg1 = (wxString *) &arg1_defvalue ;
38281 long arg2 = (long) 0 ;
38282 wxMenu *result = 0 ;
38283 bool temp1 = false ;
38284 long val2 ;
38285 int ecode2 = 0 ;
38286 PyObject * obj0 = 0 ;
38287 PyObject * obj1 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "title",(char *) "style", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38293 if (obj0) {
38294 {
38295 arg1 = wxString_in_helper(obj0);
38296 if (arg1 == NULL) SWIG_fail;
38297 temp1 = true;
38298 }
38299 }
38300 if (obj1) {
38301 ecode2 = SWIG_AsVal_long(obj1, &val2);
38302 if (!SWIG_IsOK(ecode2)) {
38303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38304 }
38305 arg2 = static_cast< long >(val2);
38306 }
38307 {
38308 if (!wxPyCheckForApp()) SWIG_fail;
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38315 {
38316 if (temp1)
38317 delete arg1;
38318 }
38319 return resultobj;
38320 fail:
38321 {
38322 if (temp1)
38323 delete arg1;
38324 }
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj = 0;
38331 wxMenu *arg1 = (wxMenu *) 0 ;
38332 int arg2 ;
38333 wxString *arg3 = 0 ;
38334 wxString const &arg4_defvalue = wxPyEmptyString ;
38335 wxString *arg4 = (wxString *) &arg4_defvalue ;
38336 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38337 wxMenuItem *result = 0 ;
38338 void *argp1 = 0 ;
38339 int res1 = 0 ;
38340 int val2 ;
38341 int ecode2 = 0 ;
38342 bool temp3 = false ;
38343 bool temp4 = false ;
38344 int val5 ;
38345 int ecode5 = 0 ;
38346 PyObject * obj0 = 0 ;
38347 PyObject * obj1 = 0 ;
38348 PyObject * obj2 = 0 ;
38349 PyObject * obj3 = 0 ;
38350 PyObject * obj4 = 0 ;
38351 char * kwnames[] = {
38352 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38353 };
38354
38355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38357 if (!SWIG_IsOK(res1)) {
38358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38359 }
38360 arg1 = reinterpret_cast< wxMenu * >(argp1);
38361 ecode2 = SWIG_AsVal_int(obj1, &val2);
38362 if (!SWIG_IsOK(ecode2)) {
38363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38364 }
38365 arg2 = static_cast< int >(val2);
38366 {
38367 arg3 = wxString_in_helper(obj2);
38368 if (arg3 == NULL) SWIG_fail;
38369 temp3 = true;
38370 }
38371 if (obj3) {
38372 {
38373 arg4 = wxString_in_helper(obj3);
38374 if (arg4 == NULL) SWIG_fail;
38375 temp4 = true;
38376 }
38377 }
38378 if (obj4) {
38379 ecode5 = SWIG_AsVal_int(obj4, &val5);
38380 if (!SWIG_IsOK(ecode5)) {
38381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38382 }
38383 arg5 = static_cast< wxItemKind >(val5);
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 {
38392 resultobj = wxPyMake_wxObject(result, (bool)0);
38393 }
38394 {
38395 if (temp3)
38396 delete arg3;
38397 }
38398 {
38399 if (temp4)
38400 delete arg4;
38401 }
38402 return resultobj;
38403 fail:
38404 {
38405 if (temp3)
38406 delete arg3;
38407 }
38408 {
38409 if (temp4)
38410 delete arg4;
38411 }
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38417 PyObject *resultobj = 0;
38418 wxMenu *arg1 = (wxMenu *) 0 ;
38419 wxMenuItem *result = 0 ;
38420 void *argp1 = 0 ;
38421 int res1 = 0 ;
38422 PyObject *swig_obj[1] ;
38423
38424 if (!args) SWIG_fail;
38425 swig_obj[0] = args;
38426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38427 if (!SWIG_IsOK(res1)) {
38428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38429 }
38430 arg1 = reinterpret_cast< wxMenu * >(argp1);
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 result = (wxMenuItem *)(arg1)->AppendSeparator();
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 {
38438 resultobj = wxPyMake_wxObject(result, (bool)0);
38439 }
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj = 0;
38448 wxMenu *arg1 = (wxMenu *) 0 ;
38449 int arg2 ;
38450 wxString *arg3 = 0 ;
38451 wxString const &arg4_defvalue = wxPyEmptyString ;
38452 wxString *arg4 = (wxString *) &arg4_defvalue ;
38453 wxMenuItem *result = 0 ;
38454 void *argp1 = 0 ;
38455 int res1 = 0 ;
38456 int val2 ;
38457 int ecode2 = 0 ;
38458 bool temp3 = false ;
38459 bool temp4 = false ;
38460 PyObject * obj0 = 0 ;
38461 PyObject * obj1 = 0 ;
38462 PyObject * obj2 = 0 ;
38463 PyObject * obj3 = 0 ;
38464 char * kwnames[] = {
38465 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38466 };
38467
38468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38470 if (!SWIG_IsOK(res1)) {
38471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38472 }
38473 arg1 = reinterpret_cast< wxMenu * >(argp1);
38474 ecode2 = SWIG_AsVal_int(obj1, &val2);
38475 if (!SWIG_IsOK(ecode2)) {
38476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38477 }
38478 arg2 = static_cast< int >(val2);
38479 {
38480 arg3 = wxString_in_helper(obj2);
38481 if (arg3 == NULL) SWIG_fail;
38482 temp3 = true;
38483 }
38484 if (obj3) {
38485 {
38486 arg4 = wxString_in_helper(obj3);
38487 if (arg4 == NULL) SWIG_fail;
38488 temp4 = true;
38489 }
38490 }
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38494 wxPyEndAllowThreads(__tstate);
38495 if (PyErr_Occurred()) SWIG_fail;
38496 }
38497 {
38498 resultobj = wxPyMake_wxObject(result, (bool)0);
38499 }
38500 {
38501 if (temp3)
38502 delete arg3;
38503 }
38504 {
38505 if (temp4)
38506 delete arg4;
38507 }
38508 return resultobj;
38509 fail:
38510 {
38511 if (temp3)
38512 delete arg3;
38513 }
38514 {
38515 if (temp4)
38516 delete arg4;
38517 }
38518 return NULL;
38519 }
38520
38521
38522 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38523 PyObject *resultobj = 0;
38524 wxMenu *arg1 = (wxMenu *) 0 ;
38525 int arg2 ;
38526 wxString *arg3 = 0 ;
38527 wxString const &arg4_defvalue = wxPyEmptyString ;
38528 wxString *arg4 = (wxString *) &arg4_defvalue ;
38529 wxMenuItem *result = 0 ;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 int val2 ;
38533 int ecode2 = 0 ;
38534 bool temp3 = false ;
38535 bool temp4 = false ;
38536 PyObject * obj0 = 0 ;
38537 PyObject * obj1 = 0 ;
38538 PyObject * obj2 = 0 ;
38539 PyObject * obj3 = 0 ;
38540 char * kwnames[] = {
38541 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38542 };
38543
38544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38546 if (!SWIG_IsOK(res1)) {
38547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38548 }
38549 arg1 = reinterpret_cast< wxMenu * >(argp1);
38550 ecode2 = SWIG_AsVal_int(obj1, &val2);
38551 if (!SWIG_IsOK(ecode2)) {
38552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38553 }
38554 arg2 = static_cast< int >(val2);
38555 {
38556 arg3 = wxString_in_helper(obj2);
38557 if (arg3 == NULL) SWIG_fail;
38558 temp3 = true;
38559 }
38560 if (obj3) {
38561 {
38562 arg4 = wxString_in_helper(obj3);
38563 if (arg4 == NULL) SWIG_fail;
38564 temp4 = true;
38565 }
38566 }
38567 {
38568 PyThreadState* __tstate = wxPyBeginAllowThreads();
38569 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38570 wxPyEndAllowThreads(__tstate);
38571 if (PyErr_Occurred()) SWIG_fail;
38572 }
38573 {
38574 resultobj = wxPyMake_wxObject(result, (bool)0);
38575 }
38576 {
38577 if (temp3)
38578 delete arg3;
38579 }
38580 {
38581 if (temp4)
38582 delete arg4;
38583 }
38584 return resultobj;
38585 fail:
38586 {
38587 if (temp3)
38588 delete arg3;
38589 }
38590 {
38591 if (temp4)
38592 delete arg4;
38593 }
38594 return NULL;
38595 }
38596
38597
38598 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj = 0;
38600 wxMenu *arg1 = (wxMenu *) 0 ;
38601 int arg2 ;
38602 wxString *arg3 = 0 ;
38603 wxMenu *arg4 = (wxMenu *) 0 ;
38604 wxString const &arg5_defvalue = wxPyEmptyString ;
38605 wxString *arg5 = (wxString *) &arg5_defvalue ;
38606 wxMenuItem *result = 0 ;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 int val2 ;
38610 int ecode2 = 0 ;
38611 bool temp3 = false ;
38612 void *argp4 = 0 ;
38613 int res4 = 0 ;
38614 bool temp5 = false ;
38615 PyObject * obj0 = 0 ;
38616 PyObject * obj1 = 0 ;
38617 PyObject * obj2 = 0 ;
38618 PyObject * obj3 = 0 ;
38619 PyObject * obj4 = 0 ;
38620 char * kwnames[] = {
38621 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38622 };
38623
38624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38628 }
38629 arg1 = reinterpret_cast< wxMenu * >(argp1);
38630 ecode2 = SWIG_AsVal_int(obj1, &val2);
38631 if (!SWIG_IsOK(ecode2)) {
38632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38633 }
38634 arg2 = static_cast< int >(val2);
38635 {
38636 arg3 = wxString_in_helper(obj2);
38637 if (arg3 == NULL) SWIG_fail;
38638 temp3 = true;
38639 }
38640 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38641 if (!SWIG_IsOK(res4)) {
38642 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38643 }
38644 arg4 = reinterpret_cast< wxMenu * >(argp4);
38645 if (obj4) {
38646 {
38647 arg5 = wxString_in_helper(obj4);
38648 if (arg5 == NULL) SWIG_fail;
38649 temp5 = true;
38650 }
38651 }
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 {
38659 resultobj = wxPyMake_wxObject(result, (bool)0);
38660 }
38661 {
38662 if (temp3)
38663 delete arg3;
38664 }
38665 {
38666 if (temp5)
38667 delete arg5;
38668 }
38669 return resultobj;
38670 fail:
38671 {
38672 if (temp3)
38673 delete arg3;
38674 }
38675 {
38676 if (temp5)
38677 delete arg5;
38678 }
38679 return NULL;
38680 }
38681
38682
38683 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38684 PyObject *resultobj = 0;
38685 wxMenu *arg1 = (wxMenu *) 0 ;
38686 wxMenu *arg2 = (wxMenu *) 0 ;
38687 wxString *arg3 = 0 ;
38688 wxString const &arg4_defvalue = wxPyEmptyString ;
38689 wxString *arg4 = (wxString *) &arg4_defvalue ;
38690 wxMenuItem *result = 0 ;
38691 void *argp1 = 0 ;
38692 int res1 = 0 ;
38693 void *argp2 = 0 ;
38694 int res2 = 0 ;
38695 bool temp3 = false ;
38696 bool temp4 = false ;
38697 PyObject * obj0 = 0 ;
38698 PyObject * obj1 = 0 ;
38699 PyObject * obj2 = 0 ;
38700 PyObject * obj3 = 0 ;
38701 char * kwnames[] = {
38702 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38703 };
38704
38705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38709 }
38710 arg1 = reinterpret_cast< wxMenu * >(argp1);
38711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38712 if (!SWIG_IsOK(res2)) {
38713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38714 }
38715 arg2 = reinterpret_cast< wxMenu * >(argp2);
38716 {
38717 arg3 = wxString_in_helper(obj2);
38718 if (arg3 == NULL) SWIG_fail;
38719 temp3 = true;
38720 }
38721 if (obj3) {
38722 {
38723 arg4 = wxString_in_helper(obj3);
38724 if (arg4 == NULL) SWIG_fail;
38725 temp4 = true;
38726 }
38727 }
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38731 wxPyEndAllowThreads(__tstate);
38732 if (PyErr_Occurred()) SWIG_fail;
38733 }
38734 {
38735 resultobj = wxPyMake_wxObject(result, (bool)0);
38736 }
38737 {
38738 if (temp3)
38739 delete arg3;
38740 }
38741 {
38742 if (temp4)
38743 delete arg4;
38744 }
38745 return resultobj;
38746 fail:
38747 {
38748 if (temp3)
38749 delete arg3;
38750 }
38751 {
38752 if (temp4)
38753 delete arg4;
38754 }
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj = 0;
38761 wxMenu *arg1 = (wxMenu *) 0 ;
38762 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38763 wxMenuItem *result = 0 ;
38764 void *argp1 = 0 ;
38765 int res1 = 0 ;
38766 int res2 = 0 ;
38767 PyObject * obj0 = 0 ;
38768 PyObject * obj1 = 0 ;
38769 char * kwnames[] = {
38770 (char *) "self",(char *) "item", NULL
38771 };
38772
38773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38777 }
38778 arg1 = reinterpret_cast< wxMenu * >(argp1);
38779 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38780 if (!SWIG_IsOK(res2)) {
38781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38782 }
38783 {
38784 PyThreadState* __tstate = wxPyBeginAllowThreads();
38785 result = (wxMenuItem *)(arg1)->Append(arg2);
38786 wxPyEndAllowThreads(__tstate);
38787 if (PyErr_Occurred()) SWIG_fail;
38788 }
38789 {
38790 resultobj = wxPyMake_wxObject(result, (bool)0);
38791 }
38792 return resultobj;
38793 fail:
38794 return NULL;
38795 }
38796
38797
38798 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38799 PyObject *resultobj = 0;
38800 wxMenu *arg1 = (wxMenu *) 0 ;
38801 size_t arg2 ;
38802 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38803 wxMenuItem *result = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 size_t val2 ;
38807 int ecode2 = 0 ;
38808 int res3 = 0 ;
38809 PyObject * obj0 = 0 ;
38810 PyObject * obj1 = 0 ;
38811 PyObject * obj2 = 0 ;
38812 char * kwnames[] = {
38813 (char *) "self",(char *) "pos",(char *) "item", NULL
38814 };
38815
38816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38820 }
38821 arg1 = reinterpret_cast< wxMenu * >(argp1);
38822 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38823 if (!SWIG_IsOK(ecode2)) {
38824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38825 }
38826 arg2 = static_cast< size_t >(val2);
38827 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38828 if (!SWIG_IsOK(res3)) {
38829 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38830 }
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38834 wxPyEndAllowThreads(__tstate);
38835 if (PyErr_Occurred()) SWIG_fail;
38836 }
38837 {
38838 resultobj = wxPyMake_wxObject(result, (bool)0);
38839 }
38840 return resultobj;
38841 fail:
38842 return NULL;
38843 }
38844
38845
38846 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj = 0;
38848 wxMenu *arg1 = (wxMenu *) 0 ;
38849 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38850 wxMenuItem *result = 0 ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 int res2 = 0 ;
38854 PyObject * obj0 = 0 ;
38855 PyObject * obj1 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "item", NULL
38858 };
38859
38860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38864 }
38865 arg1 = reinterpret_cast< wxMenu * >(argp1);
38866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38867 if (!SWIG_IsOK(res2)) {
38868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38869 }
38870 {
38871 PyThreadState* __tstate = wxPyBeginAllowThreads();
38872 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 {
38877 resultobj = wxPyMake_wxObject(result, (bool)0);
38878 }
38879 return resultobj;
38880 fail:
38881 return NULL;
38882 }
38883
38884
38885 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38886 PyObject *resultobj = 0;
38887 wxMenu *arg1 = (wxMenu *) 0 ;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 PyObject *swig_obj[1] ;
38891
38892 if (!args) SWIG_fail;
38893 swig_obj[0] = args;
38894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38895 if (!SWIG_IsOK(res1)) {
38896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38897 }
38898 arg1 = reinterpret_cast< wxMenu * >(argp1);
38899 {
38900 PyThreadState* __tstate = wxPyBeginAllowThreads();
38901 (arg1)->Break();
38902 wxPyEndAllowThreads(__tstate);
38903 if (PyErr_Occurred()) SWIG_fail;
38904 }
38905 resultobj = SWIG_Py_Void();
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38913 PyObject *resultobj = 0;
38914 wxMenu *arg1 = (wxMenu *) 0 ;
38915 size_t arg2 ;
38916 int arg3 ;
38917 wxString *arg4 = 0 ;
38918 wxString const &arg5_defvalue = wxPyEmptyString ;
38919 wxString *arg5 = (wxString *) &arg5_defvalue ;
38920 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38921 wxMenuItem *result = 0 ;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 size_t val2 ;
38925 int ecode2 = 0 ;
38926 int val3 ;
38927 int ecode3 = 0 ;
38928 bool temp4 = false ;
38929 bool temp5 = false ;
38930 int val6 ;
38931 int ecode6 = 0 ;
38932 PyObject * obj0 = 0 ;
38933 PyObject * obj1 = 0 ;
38934 PyObject * obj2 = 0 ;
38935 PyObject * obj3 = 0 ;
38936 PyObject * obj4 = 0 ;
38937 PyObject * obj5 = 0 ;
38938 char * kwnames[] = {
38939 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38940 };
38941
38942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38944 if (!SWIG_IsOK(res1)) {
38945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38946 }
38947 arg1 = reinterpret_cast< wxMenu * >(argp1);
38948 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38949 if (!SWIG_IsOK(ecode2)) {
38950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38951 }
38952 arg2 = static_cast< size_t >(val2);
38953 ecode3 = SWIG_AsVal_int(obj2, &val3);
38954 if (!SWIG_IsOK(ecode3)) {
38955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38956 }
38957 arg3 = static_cast< int >(val3);
38958 {
38959 arg4 = wxString_in_helper(obj3);
38960 if (arg4 == NULL) SWIG_fail;
38961 temp4 = true;
38962 }
38963 if (obj4) {
38964 {
38965 arg5 = wxString_in_helper(obj4);
38966 if (arg5 == NULL) SWIG_fail;
38967 temp5 = true;
38968 }
38969 }
38970 if (obj5) {
38971 ecode6 = SWIG_AsVal_int(obj5, &val6);
38972 if (!SWIG_IsOK(ecode6)) {
38973 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38974 }
38975 arg6 = static_cast< wxItemKind >(val6);
38976 }
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = wxPyMake_wxObject(result, (bool)0);
38985 }
38986 {
38987 if (temp4)
38988 delete arg4;
38989 }
38990 {
38991 if (temp5)
38992 delete arg5;
38993 }
38994 return resultobj;
38995 fail:
38996 {
38997 if (temp4)
38998 delete arg4;
38999 }
39000 {
39001 if (temp5)
39002 delete arg5;
39003 }
39004 return NULL;
39005 }
39006
39007
39008 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj = 0;
39010 wxMenu *arg1 = (wxMenu *) 0 ;
39011 size_t arg2 ;
39012 wxMenuItem *result = 0 ;
39013 void *argp1 = 0 ;
39014 int res1 = 0 ;
39015 size_t val2 ;
39016 int ecode2 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 char * kwnames[] = {
39020 (char *) "self",(char *) "pos", NULL
39021 };
39022
39023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39025 if (!SWIG_IsOK(res1)) {
39026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39027 }
39028 arg1 = reinterpret_cast< wxMenu * >(argp1);
39029 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39030 if (!SWIG_IsOK(ecode2)) {
39031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39032 }
39033 arg2 = static_cast< size_t >(val2);
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 {
39041 resultobj = wxPyMake_wxObject(result, (bool)0);
39042 }
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39050 PyObject *resultobj = 0;
39051 wxMenu *arg1 = (wxMenu *) 0 ;
39052 size_t arg2 ;
39053 int arg3 ;
39054 wxString *arg4 = 0 ;
39055 wxString const &arg5_defvalue = wxPyEmptyString ;
39056 wxString *arg5 = (wxString *) &arg5_defvalue ;
39057 wxMenuItem *result = 0 ;
39058 void *argp1 = 0 ;
39059 int res1 = 0 ;
39060 size_t val2 ;
39061 int ecode2 = 0 ;
39062 int val3 ;
39063 int ecode3 = 0 ;
39064 bool temp4 = false ;
39065 bool temp5 = false ;
39066 PyObject * obj0 = 0 ;
39067 PyObject * obj1 = 0 ;
39068 PyObject * obj2 = 0 ;
39069 PyObject * obj3 = 0 ;
39070 PyObject * obj4 = 0 ;
39071 char * kwnames[] = {
39072 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39073 };
39074
39075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39077 if (!SWIG_IsOK(res1)) {
39078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39079 }
39080 arg1 = reinterpret_cast< wxMenu * >(argp1);
39081 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39082 if (!SWIG_IsOK(ecode2)) {
39083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39084 }
39085 arg2 = static_cast< size_t >(val2);
39086 ecode3 = SWIG_AsVal_int(obj2, &val3);
39087 if (!SWIG_IsOK(ecode3)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39089 }
39090 arg3 = static_cast< int >(val3);
39091 {
39092 arg4 = wxString_in_helper(obj3);
39093 if (arg4 == NULL) SWIG_fail;
39094 temp4 = true;
39095 }
39096 if (obj4) {
39097 {
39098 arg5 = wxString_in_helper(obj4);
39099 if (arg5 == NULL) SWIG_fail;
39100 temp5 = true;
39101 }
39102 }
39103 {
39104 PyThreadState* __tstate = wxPyBeginAllowThreads();
39105 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 {
39110 resultobj = wxPyMake_wxObject(result, (bool)0);
39111 }
39112 {
39113 if (temp4)
39114 delete arg4;
39115 }
39116 {
39117 if (temp5)
39118 delete arg5;
39119 }
39120 return resultobj;
39121 fail:
39122 {
39123 if (temp4)
39124 delete arg4;
39125 }
39126 {
39127 if (temp5)
39128 delete arg5;
39129 }
39130 return NULL;
39131 }
39132
39133
39134 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj = 0;
39136 wxMenu *arg1 = (wxMenu *) 0 ;
39137 size_t arg2 ;
39138 int arg3 ;
39139 wxString *arg4 = 0 ;
39140 wxString const &arg5_defvalue = wxPyEmptyString ;
39141 wxString *arg5 = (wxString *) &arg5_defvalue ;
39142 wxMenuItem *result = 0 ;
39143 void *argp1 = 0 ;
39144 int res1 = 0 ;
39145 size_t val2 ;
39146 int ecode2 = 0 ;
39147 int val3 ;
39148 int ecode3 = 0 ;
39149 bool temp4 = false ;
39150 bool temp5 = false ;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 PyObject * obj3 = 0 ;
39155 PyObject * obj4 = 0 ;
39156 char * kwnames[] = {
39157 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39158 };
39159
39160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39162 if (!SWIG_IsOK(res1)) {
39163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39164 }
39165 arg1 = reinterpret_cast< wxMenu * >(argp1);
39166 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39167 if (!SWIG_IsOK(ecode2)) {
39168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39169 }
39170 arg2 = static_cast< size_t >(val2);
39171 ecode3 = SWIG_AsVal_int(obj2, &val3);
39172 if (!SWIG_IsOK(ecode3)) {
39173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39174 }
39175 arg3 = static_cast< int >(val3);
39176 {
39177 arg4 = wxString_in_helper(obj3);
39178 if (arg4 == NULL) SWIG_fail;
39179 temp4 = true;
39180 }
39181 if (obj4) {
39182 {
39183 arg5 = wxString_in_helper(obj4);
39184 if (arg5 == NULL) SWIG_fail;
39185 temp5 = true;
39186 }
39187 }
39188 {
39189 PyThreadState* __tstate = wxPyBeginAllowThreads();
39190 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 {
39195 resultobj = wxPyMake_wxObject(result, (bool)0);
39196 }
39197 {
39198 if (temp4)
39199 delete arg4;
39200 }
39201 {
39202 if (temp5)
39203 delete arg5;
39204 }
39205 return resultobj;
39206 fail:
39207 {
39208 if (temp4)
39209 delete arg4;
39210 }
39211 {
39212 if (temp5)
39213 delete arg5;
39214 }
39215 return NULL;
39216 }
39217
39218
39219 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj = 0;
39221 wxMenu *arg1 = (wxMenu *) 0 ;
39222 size_t arg2 ;
39223 int arg3 ;
39224 wxString *arg4 = 0 ;
39225 wxMenu *arg5 = (wxMenu *) 0 ;
39226 wxString const &arg6_defvalue = wxPyEmptyString ;
39227 wxString *arg6 = (wxString *) &arg6_defvalue ;
39228 wxMenuItem *result = 0 ;
39229 void *argp1 = 0 ;
39230 int res1 = 0 ;
39231 size_t val2 ;
39232 int ecode2 = 0 ;
39233 int val3 ;
39234 int ecode3 = 0 ;
39235 bool temp4 = false ;
39236 void *argp5 = 0 ;
39237 int res5 = 0 ;
39238 bool temp6 = false ;
39239 PyObject * obj0 = 0 ;
39240 PyObject * obj1 = 0 ;
39241 PyObject * obj2 = 0 ;
39242 PyObject * obj3 = 0 ;
39243 PyObject * obj4 = 0 ;
39244 PyObject * obj5 = 0 ;
39245 char * kwnames[] = {
39246 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39247 };
39248
39249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39251 if (!SWIG_IsOK(res1)) {
39252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39253 }
39254 arg1 = reinterpret_cast< wxMenu * >(argp1);
39255 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39256 if (!SWIG_IsOK(ecode2)) {
39257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39258 }
39259 arg2 = static_cast< size_t >(val2);
39260 ecode3 = SWIG_AsVal_int(obj2, &val3);
39261 if (!SWIG_IsOK(ecode3)) {
39262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39263 }
39264 arg3 = static_cast< int >(val3);
39265 {
39266 arg4 = wxString_in_helper(obj3);
39267 if (arg4 == NULL) SWIG_fail;
39268 temp4 = true;
39269 }
39270 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39271 if (!SWIG_IsOK(res5)) {
39272 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39273 }
39274 arg5 = reinterpret_cast< wxMenu * >(argp5);
39275 if (obj5) {
39276 {
39277 arg6 = wxString_in_helper(obj5);
39278 if (arg6 == NULL) SWIG_fail;
39279 temp6 = true;
39280 }
39281 }
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)0);
39290 }
39291 {
39292 if (temp4)
39293 delete arg4;
39294 }
39295 {
39296 if (temp6)
39297 delete arg6;
39298 }
39299 return resultobj;
39300 fail:
39301 {
39302 if (temp4)
39303 delete arg4;
39304 }
39305 {
39306 if (temp6)
39307 delete arg6;
39308 }
39309 return NULL;
39310 }
39311
39312
39313 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj = 0;
39315 wxMenu *arg1 = (wxMenu *) 0 ;
39316 int arg2 ;
39317 wxString *arg3 = 0 ;
39318 wxString const &arg4_defvalue = wxPyEmptyString ;
39319 wxString *arg4 = (wxString *) &arg4_defvalue ;
39320 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39321 wxMenuItem *result = 0 ;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 int val2 ;
39325 int ecode2 = 0 ;
39326 bool temp3 = false ;
39327 bool temp4 = false ;
39328 int val5 ;
39329 int ecode5 = 0 ;
39330 PyObject * obj0 = 0 ;
39331 PyObject * obj1 = 0 ;
39332 PyObject * obj2 = 0 ;
39333 PyObject * obj3 = 0 ;
39334 PyObject * obj4 = 0 ;
39335 char * kwnames[] = {
39336 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39337 };
39338
39339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39341 if (!SWIG_IsOK(res1)) {
39342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39343 }
39344 arg1 = reinterpret_cast< wxMenu * >(argp1);
39345 ecode2 = SWIG_AsVal_int(obj1, &val2);
39346 if (!SWIG_IsOK(ecode2)) {
39347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39348 }
39349 arg2 = static_cast< int >(val2);
39350 {
39351 arg3 = wxString_in_helper(obj2);
39352 if (arg3 == NULL) SWIG_fail;
39353 temp3 = true;
39354 }
39355 if (obj3) {
39356 {
39357 arg4 = wxString_in_helper(obj3);
39358 if (arg4 == NULL) SWIG_fail;
39359 temp4 = true;
39360 }
39361 }
39362 if (obj4) {
39363 ecode5 = SWIG_AsVal_int(obj4, &val5);
39364 if (!SWIG_IsOK(ecode5)) {
39365 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39366 }
39367 arg5 = static_cast< wxItemKind >(val5);
39368 }
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 {
39376 resultobj = wxPyMake_wxObject(result, (bool)0);
39377 }
39378 {
39379 if (temp3)
39380 delete arg3;
39381 }
39382 {
39383 if (temp4)
39384 delete arg4;
39385 }
39386 return resultobj;
39387 fail:
39388 {
39389 if (temp3)
39390 delete arg3;
39391 }
39392 {
39393 if (temp4)
39394 delete arg4;
39395 }
39396 return NULL;
39397 }
39398
39399
39400 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39401 PyObject *resultobj = 0;
39402 wxMenu *arg1 = (wxMenu *) 0 ;
39403 wxMenuItem *result = 0 ;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 PyObject *swig_obj[1] ;
39407
39408 if (!args) SWIG_fail;
39409 swig_obj[0] = args;
39410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39413 }
39414 arg1 = reinterpret_cast< wxMenu * >(argp1);
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 result = (wxMenuItem *)(arg1)->PrependSeparator();
39418 wxPyEndAllowThreads(__tstate);
39419 if (PyErr_Occurred()) SWIG_fail;
39420 }
39421 {
39422 resultobj = wxPyMake_wxObject(result, (bool)0);
39423 }
39424 return resultobj;
39425 fail:
39426 return NULL;
39427 }
39428
39429
39430 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39431 PyObject *resultobj = 0;
39432 wxMenu *arg1 = (wxMenu *) 0 ;
39433 int arg2 ;
39434 wxString *arg3 = 0 ;
39435 wxString const &arg4_defvalue = wxPyEmptyString ;
39436 wxString *arg4 = (wxString *) &arg4_defvalue ;
39437 wxMenuItem *result = 0 ;
39438 void *argp1 = 0 ;
39439 int res1 = 0 ;
39440 int val2 ;
39441 int ecode2 = 0 ;
39442 bool temp3 = false ;
39443 bool temp4 = false ;
39444 PyObject * obj0 = 0 ;
39445 PyObject * obj1 = 0 ;
39446 PyObject * obj2 = 0 ;
39447 PyObject * obj3 = 0 ;
39448 char * kwnames[] = {
39449 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39450 };
39451
39452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39454 if (!SWIG_IsOK(res1)) {
39455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39456 }
39457 arg1 = reinterpret_cast< wxMenu * >(argp1);
39458 ecode2 = SWIG_AsVal_int(obj1, &val2);
39459 if (!SWIG_IsOK(ecode2)) {
39460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39461 }
39462 arg2 = static_cast< int >(val2);
39463 {
39464 arg3 = wxString_in_helper(obj2);
39465 if (arg3 == NULL) SWIG_fail;
39466 temp3 = true;
39467 }
39468 if (obj3) {
39469 {
39470 arg4 = wxString_in_helper(obj3);
39471 if (arg4 == NULL) SWIG_fail;
39472 temp4 = true;
39473 }
39474 }
39475 {
39476 PyThreadState* __tstate = wxPyBeginAllowThreads();
39477 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39478 wxPyEndAllowThreads(__tstate);
39479 if (PyErr_Occurred()) SWIG_fail;
39480 }
39481 {
39482 resultobj = wxPyMake_wxObject(result, (bool)0);
39483 }
39484 {
39485 if (temp3)
39486 delete arg3;
39487 }
39488 {
39489 if (temp4)
39490 delete arg4;
39491 }
39492 return resultobj;
39493 fail:
39494 {
39495 if (temp3)
39496 delete arg3;
39497 }
39498 {
39499 if (temp4)
39500 delete arg4;
39501 }
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39507 PyObject *resultobj = 0;
39508 wxMenu *arg1 = (wxMenu *) 0 ;
39509 int arg2 ;
39510 wxString *arg3 = 0 ;
39511 wxString const &arg4_defvalue = wxPyEmptyString ;
39512 wxString *arg4 = (wxString *) &arg4_defvalue ;
39513 wxMenuItem *result = 0 ;
39514 void *argp1 = 0 ;
39515 int res1 = 0 ;
39516 int val2 ;
39517 int ecode2 = 0 ;
39518 bool temp3 = false ;
39519 bool temp4 = false ;
39520 PyObject * obj0 = 0 ;
39521 PyObject * obj1 = 0 ;
39522 PyObject * obj2 = 0 ;
39523 PyObject * obj3 = 0 ;
39524 char * kwnames[] = {
39525 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39526 };
39527
39528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39530 if (!SWIG_IsOK(res1)) {
39531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39532 }
39533 arg1 = reinterpret_cast< wxMenu * >(argp1);
39534 ecode2 = SWIG_AsVal_int(obj1, &val2);
39535 if (!SWIG_IsOK(ecode2)) {
39536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39537 }
39538 arg2 = static_cast< int >(val2);
39539 {
39540 arg3 = wxString_in_helper(obj2);
39541 if (arg3 == NULL) SWIG_fail;
39542 temp3 = true;
39543 }
39544 if (obj3) {
39545 {
39546 arg4 = wxString_in_helper(obj3);
39547 if (arg4 == NULL) SWIG_fail;
39548 temp4 = true;
39549 }
39550 }
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 {
39558 resultobj = wxPyMake_wxObject(result, (bool)0);
39559 }
39560 {
39561 if (temp3)
39562 delete arg3;
39563 }
39564 {
39565 if (temp4)
39566 delete arg4;
39567 }
39568 return resultobj;
39569 fail:
39570 {
39571 if (temp3)
39572 delete arg3;
39573 }
39574 {
39575 if (temp4)
39576 delete arg4;
39577 }
39578 return NULL;
39579 }
39580
39581
39582 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj = 0;
39584 wxMenu *arg1 = (wxMenu *) 0 ;
39585 int arg2 ;
39586 wxString *arg3 = 0 ;
39587 wxMenu *arg4 = (wxMenu *) 0 ;
39588 wxString const &arg5_defvalue = wxPyEmptyString ;
39589 wxString *arg5 = (wxString *) &arg5_defvalue ;
39590 wxMenuItem *result = 0 ;
39591 void *argp1 = 0 ;
39592 int res1 = 0 ;
39593 int val2 ;
39594 int ecode2 = 0 ;
39595 bool temp3 = false ;
39596 void *argp4 = 0 ;
39597 int res4 = 0 ;
39598 bool temp5 = false ;
39599 PyObject * obj0 = 0 ;
39600 PyObject * obj1 = 0 ;
39601 PyObject * obj2 = 0 ;
39602 PyObject * obj3 = 0 ;
39603 PyObject * obj4 = 0 ;
39604 char * kwnames[] = {
39605 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39606 };
39607
39608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39610 if (!SWIG_IsOK(res1)) {
39611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39612 }
39613 arg1 = reinterpret_cast< wxMenu * >(argp1);
39614 ecode2 = SWIG_AsVal_int(obj1, &val2);
39615 if (!SWIG_IsOK(ecode2)) {
39616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39617 }
39618 arg2 = static_cast< int >(val2);
39619 {
39620 arg3 = wxString_in_helper(obj2);
39621 if (arg3 == NULL) SWIG_fail;
39622 temp3 = true;
39623 }
39624 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39625 if (!SWIG_IsOK(res4)) {
39626 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39627 }
39628 arg4 = reinterpret_cast< wxMenu * >(argp4);
39629 if (obj4) {
39630 {
39631 arg5 = wxString_in_helper(obj4);
39632 if (arg5 == NULL) SWIG_fail;
39633 temp5 = true;
39634 }
39635 }
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 {
39643 resultobj = wxPyMake_wxObject(result, (bool)0);
39644 }
39645 {
39646 if (temp3)
39647 delete arg3;
39648 }
39649 {
39650 if (temp5)
39651 delete arg5;
39652 }
39653 return resultobj;
39654 fail:
39655 {
39656 if (temp3)
39657 delete arg3;
39658 }
39659 {
39660 if (temp5)
39661 delete arg5;
39662 }
39663 return NULL;
39664 }
39665
39666
39667 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39668 PyObject *resultobj = 0;
39669 wxMenu *arg1 = (wxMenu *) 0 ;
39670 int arg2 ;
39671 wxMenuItem *result = 0 ;
39672 void *argp1 = 0 ;
39673 int res1 = 0 ;
39674 int val2 ;
39675 int ecode2 = 0 ;
39676 PyObject * obj0 = 0 ;
39677 PyObject * obj1 = 0 ;
39678 char * kwnames[] = {
39679 (char *) "self",(char *) "id", NULL
39680 };
39681
39682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39684 if (!SWIG_IsOK(res1)) {
39685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39686 }
39687 arg1 = reinterpret_cast< wxMenu * >(argp1);
39688 ecode2 = SWIG_AsVal_int(obj1, &val2);
39689 if (!SWIG_IsOK(ecode2)) {
39690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39691 }
39692 arg2 = static_cast< int >(val2);
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (wxMenuItem *)(arg1)->Remove(arg2);
39696 wxPyEndAllowThreads(__tstate);
39697 if (PyErr_Occurred()) SWIG_fail;
39698 }
39699 {
39700 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39701 }
39702 return resultobj;
39703 fail:
39704 return NULL;
39705 }
39706
39707
39708 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39709 PyObject *resultobj = 0;
39710 wxMenu *arg1 = (wxMenu *) 0 ;
39711 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39712 wxMenuItem *result = 0 ;
39713 void *argp1 = 0 ;
39714 int res1 = 0 ;
39715 void *argp2 = 0 ;
39716 int res2 = 0 ;
39717 PyObject * obj0 = 0 ;
39718 PyObject * obj1 = 0 ;
39719 char * kwnames[] = {
39720 (char *) "self",(char *) "item", NULL
39721 };
39722
39723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39725 if (!SWIG_IsOK(res1)) {
39726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39727 }
39728 arg1 = reinterpret_cast< wxMenu * >(argp1);
39729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39730 if (!SWIG_IsOK(res2)) {
39731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39732 }
39733 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39734 {
39735 PyThreadState* __tstate = wxPyBeginAllowThreads();
39736 result = (wxMenuItem *)(arg1)->Remove(arg2);
39737 wxPyEndAllowThreads(__tstate);
39738 if (PyErr_Occurred()) SWIG_fail;
39739 }
39740 {
39741 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39742 }
39743 return resultobj;
39744 fail:
39745 return NULL;
39746 }
39747
39748
39749 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39750 PyObject *resultobj = 0;
39751 wxMenu *arg1 = (wxMenu *) 0 ;
39752 int arg2 ;
39753 bool result;
39754 void *argp1 = 0 ;
39755 int res1 = 0 ;
39756 int val2 ;
39757 int ecode2 = 0 ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 char * kwnames[] = {
39761 (char *) "self",(char *) "id", NULL
39762 };
39763
39764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39766 if (!SWIG_IsOK(res1)) {
39767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39768 }
39769 arg1 = reinterpret_cast< wxMenu * >(argp1);
39770 ecode2 = SWIG_AsVal_int(obj1, &val2);
39771 if (!SWIG_IsOK(ecode2)) {
39772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39773 }
39774 arg2 = static_cast< int >(val2);
39775 {
39776 PyThreadState* __tstate = wxPyBeginAllowThreads();
39777 result = (bool)(arg1)->Delete(arg2);
39778 wxPyEndAllowThreads(__tstate);
39779 if (PyErr_Occurred()) SWIG_fail;
39780 }
39781 {
39782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39783 }
39784 return resultobj;
39785 fail:
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39794 bool result;
39795 void *argp1 = 0 ;
39796 int res1 = 0 ;
39797 void *argp2 = 0 ;
39798 int res2 = 0 ;
39799 PyObject * obj0 = 0 ;
39800 PyObject * obj1 = 0 ;
39801 char * kwnames[] = {
39802 (char *) "self",(char *) "item", NULL
39803 };
39804
39805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39807 if (!SWIG_IsOK(res1)) {
39808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39809 }
39810 arg1 = reinterpret_cast< wxMenu * >(argp1);
39811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39812 if (!SWIG_IsOK(res2)) {
39813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39814 }
39815 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 result = (bool)(arg1)->Delete(arg2);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 {
39823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39824 }
39825 return resultobj;
39826 fail:
39827 return NULL;
39828 }
39829
39830
39831 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39832 PyObject *resultobj = 0;
39833 wxMenu *arg1 = (wxMenu *) 0 ;
39834 void *argp1 = 0 ;
39835 int res1 = 0 ;
39836 PyObject *swig_obj[1] ;
39837
39838 if (!args) SWIG_fail;
39839 swig_obj[0] = args;
39840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39841 if (!SWIG_IsOK(res1)) {
39842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39843 }
39844 arg1 = reinterpret_cast< wxMenu * >(argp1);
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 wxMenu_Destroy(arg1);
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 resultobj = SWIG_Py_Void();
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj = 0;
39860 wxMenu *arg1 = (wxMenu *) 0 ;
39861 int arg2 ;
39862 bool result;
39863 void *argp1 = 0 ;
39864 int res1 = 0 ;
39865 int val2 ;
39866 int ecode2 = 0 ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 char * kwnames[] = {
39870 (char *) "self",(char *) "id", NULL
39871 };
39872
39873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39877 }
39878 arg1 = reinterpret_cast< wxMenu * >(argp1);
39879 ecode2 = SWIG_AsVal_int(obj1, &val2);
39880 if (!SWIG_IsOK(ecode2)) {
39881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39882 }
39883 arg2 = static_cast< int >(val2);
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (bool)(arg1)->Destroy(arg2);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39892 }
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj = 0;
39901 wxMenu *arg1 = (wxMenu *) 0 ;
39902 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39903 bool result;
39904 void *argp1 = 0 ;
39905 int res1 = 0 ;
39906 void *argp2 = 0 ;
39907 int res2 = 0 ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 char * kwnames[] = {
39911 (char *) "self",(char *) "item", NULL
39912 };
39913
39914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39916 if (!SWIG_IsOK(res1)) {
39917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39918 }
39919 arg1 = reinterpret_cast< wxMenu * >(argp1);
39920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39921 if (!SWIG_IsOK(res2)) {
39922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39923 }
39924 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (bool)(arg1)->Destroy(arg2);
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 {
39932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39933 }
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39941 PyObject *resultobj = 0;
39942 wxMenu *arg1 = (wxMenu *) 0 ;
39943 size_t result;
39944 void *argp1 = 0 ;
39945 int res1 = 0 ;
39946 PyObject *swig_obj[1] ;
39947
39948 if (!args) SWIG_fail;
39949 swig_obj[0] = args;
39950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39951 if (!SWIG_IsOK(res1)) {
39952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39953 }
39954 arg1 = reinterpret_cast< wxMenu * >(argp1);
39955 {
39956 PyThreadState* __tstate = wxPyBeginAllowThreads();
39957 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39969 PyObject *resultobj = 0;
39970 wxMenu *arg1 = (wxMenu *) 0 ;
39971 PyObject *result = 0 ;
39972 void *argp1 = 0 ;
39973 int res1 = 0 ;
39974 PyObject *swig_obj[1] ;
39975
39976 if (!args) SWIG_fail;
39977 swig_obj[0] = args;
39978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39979 if (!SWIG_IsOK(res1)) {
39980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39981 }
39982 arg1 = reinterpret_cast< wxMenu * >(argp1);
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 resultobj = result;
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj = 0;
39998 wxMenu *arg1 = (wxMenu *) 0 ;
39999 wxString *arg2 = 0 ;
40000 int result;
40001 void *argp1 = 0 ;
40002 int res1 = 0 ;
40003 bool temp2 = false ;
40004 PyObject * obj0 = 0 ;
40005 PyObject * obj1 = 0 ;
40006 char * kwnames[] = {
40007 (char *) "self",(char *) "item", NULL
40008 };
40009
40010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40012 if (!SWIG_IsOK(res1)) {
40013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40014 }
40015 arg1 = reinterpret_cast< wxMenu * >(argp1);
40016 {
40017 arg2 = wxString_in_helper(obj1);
40018 if (arg2 == NULL) SWIG_fail;
40019 temp2 = true;
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 resultobj = SWIG_From_int(static_cast< int >(result));
40028 {
40029 if (temp2)
40030 delete arg2;
40031 }
40032 return resultobj;
40033 fail:
40034 {
40035 if (temp2)
40036 delete arg2;
40037 }
40038 return NULL;
40039 }
40040
40041
40042 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj = 0;
40044 wxMenu *arg1 = (wxMenu *) 0 ;
40045 int arg2 ;
40046 wxMenuItem *result = 0 ;
40047 void *argp1 = 0 ;
40048 int res1 = 0 ;
40049 int val2 ;
40050 int ecode2 = 0 ;
40051 PyObject * obj0 = 0 ;
40052 PyObject * obj1 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 resultobj = wxPyMake_wxObject(result, (bool)0);
40076 }
40077 return resultobj;
40078 fail:
40079 return NULL;
40080 }
40081
40082
40083 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40084 PyObject *resultobj = 0;
40085 wxMenu *arg1 = (wxMenu *) 0 ;
40086 size_t arg2 ;
40087 wxMenuItem *result = 0 ;
40088 void *argp1 = 0 ;
40089 int res1 = 0 ;
40090 size_t val2 ;
40091 int ecode2 = 0 ;
40092 PyObject * obj0 = 0 ;
40093 PyObject * obj1 = 0 ;
40094 char * kwnames[] = {
40095 (char *) "self",(char *) "position", NULL
40096 };
40097
40098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40100 if (!SWIG_IsOK(res1)) {
40101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40102 }
40103 arg1 = reinterpret_cast< wxMenu * >(argp1);
40104 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40105 if (!SWIG_IsOK(ecode2)) {
40106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40107 }
40108 arg2 = static_cast< size_t >(val2);
40109 {
40110 PyThreadState* __tstate = wxPyBeginAllowThreads();
40111 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40112 wxPyEndAllowThreads(__tstate);
40113 if (PyErr_Occurred()) SWIG_fail;
40114 }
40115 {
40116 resultobj = wxPyMake_wxObject(result, (bool)0);
40117 }
40118 return resultobj;
40119 fail:
40120 return NULL;
40121 }
40122
40123
40124 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40125 PyObject *resultobj = 0;
40126 wxMenu *arg1 = (wxMenu *) 0 ;
40127 int arg2 ;
40128 bool arg3 ;
40129 void *argp1 = 0 ;
40130 int res1 = 0 ;
40131 int val2 ;
40132 int ecode2 = 0 ;
40133 bool val3 ;
40134 int ecode3 = 0 ;
40135 PyObject * obj0 = 0 ;
40136 PyObject * obj1 = 0 ;
40137 PyObject * obj2 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "id",(char *) "enable", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40146 }
40147 arg1 = reinterpret_cast< wxMenu * >(argp1);
40148 ecode2 = SWIG_AsVal_int(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40151 }
40152 arg2 = static_cast< int >(val2);
40153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40154 if (!SWIG_IsOK(ecode3)) {
40155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40156 }
40157 arg3 = static_cast< bool >(val3);
40158 {
40159 PyThreadState* __tstate = wxPyBeginAllowThreads();
40160 (arg1)->Enable(arg2,arg3);
40161 wxPyEndAllowThreads(__tstate);
40162 if (PyErr_Occurred()) SWIG_fail;
40163 }
40164 resultobj = SWIG_Py_Void();
40165 return resultobj;
40166 fail:
40167 return NULL;
40168 }
40169
40170
40171 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj = 0;
40173 wxMenu *arg1 = (wxMenu *) 0 ;
40174 int arg2 ;
40175 bool result;
40176 void *argp1 = 0 ;
40177 int res1 = 0 ;
40178 int val2 ;
40179 int ecode2 = 0 ;
40180 PyObject * obj0 = 0 ;
40181 PyObject * obj1 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "id", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_int(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40195 }
40196 arg2 = static_cast< int >(val2);
40197 {
40198 PyThreadState* __tstate = wxPyBeginAllowThreads();
40199 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40200 wxPyEndAllowThreads(__tstate);
40201 if (PyErr_Occurred()) SWIG_fail;
40202 }
40203 {
40204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40205 }
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj = 0;
40214 wxMenu *arg1 = (wxMenu *) 0 ;
40215 int arg2 ;
40216 bool arg3 ;
40217 void *argp1 = 0 ;
40218 int res1 = 0 ;
40219 int val2 ;
40220 int ecode2 = 0 ;
40221 bool val3 ;
40222 int ecode3 = 0 ;
40223 PyObject * obj0 = 0 ;
40224 PyObject * obj1 = 0 ;
40225 PyObject * obj2 = 0 ;
40226 char * kwnames[] = {
40227 (char *) "self",(char *) "id",(char *) "check", NULL
40228 };
40229
40230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40232 if (!SWIG_IsOK(res1)) {
40233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40234 }
40235 arg1 = reinterpret_cast< wxMenu * >(argp1);
40236 ecode2 = SWIG_AsVal_int(obj1, &val2);
40237 if (!SWIG_IsOK(ecode2)) {
40238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40239 }
40240 arg2 = static_cast< int >(val2);
40241 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40242 if (!SWIG_IsOK(ecode3)) {
40243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40244 }
40245 arg3 = static_cast< bool >(val3);
40246 {
40247 PyThreadState* __tstate = wxPyBeginAllowThreads();
40248 (arg1)->Check(arg2,arg3);
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 resultobj = SWIG_Py_Void();
40253 return resultobj;
40254 fail:
40255 return NULL;
40256 }
40257
40258
40259 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40260 PyObject *resultobj = 0;
40261 wxMenu *arg1 = (wxMenu *) 0 ;
40262 int arg2 ;
40263 bool result;
40264 void *argp1 = 0 ;
40265 int res1 = 0 ;
40266 int val2 ;
40267 int ecode2 = 0 ;
40268 PyObject * obj0 = 0 ;
40269 PyObject * obj1 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "id", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40288 wxPyEndAllowThreads(__tstate);
40289 if (PyErr_Occurred()) SWIG_fail;
40290 }
40291 {
40292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40293 }
40294 return resultobj;
40295 fail:
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40301 PyObject *resultobj = 0;
40302 wxMenu *arg1 = (wxMenu *) 0 ;
40303 int arg2 ;
40304 wxString *arg3 = 0 ;
40305 void *argp1 = 0 ;
40306 int res1 = 0 ;
40307 int val2 ;
40308 int ecode2 = 0 ;
40309 bool temp3 = false ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 PyObject * obj2 = 0 ;
40313 char * kwnames[] = {
40314 (char *) "self",(char *) "id",(char *) "label", NULL
40315 };
40316
40317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40319 if (!SWIG_IsOK(res1)) {
40320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40321 }
40322 arg1 = reinterpret_cast< wxMenu * >(argp1);
40323 ecode2 = SWIG_AsVal_int(obj1, &val2);
40324 if (!SWIG_IsOK(ecode2)) {
40325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40326 }
40327 arg2 = static_cast< int >(val2);
40328 {
40329 arg3 = wxString_in_helper(obj2);
40330 if (arg3 == NULL) SWIG_fail;
40331 temp3 = true;
40332 }
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 resultobj = SWIG_Py_Void();
40340 {
40341 if (temp3)
40342 delete arg3;
40343 }
40344 return resultobj;
40345 fail:
40346 {
40347 if (temp3)
40348 delete arg3;
40349 }
40350 return NULL;
40351 }
40352
40353
40354 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj = 0;
40356 wxMenu *arg1 = (wxMenu *) 0 ;
40357 int arg2 ;
40358 wxString result;
40359 void *argp1 = 0 ;
40360 int res1 = 0 ;
40361 int val2 ;
40362 int ecode2 = 0 ;
40363 PyObject * obj0 = 0 ;
40364 PyObject * obj1 = 0 ;
40365 char * kwnames[] = {
40366 (char *) "self",(char *) "id", NULL
40367 };
40368
40369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40371 if (!SWIG_IsOK(res1)) {
40372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40373 }
40374 arg1 = reinterpret_cast< wxMenu * >(argp1);
40375 ecode2 = SWIG_AsVal_int(obj1, &val2);
40376 if (!SWIG_IsOK(ecode2)) {
40377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40378 }
40379 arg2 = static_cast< int >(val2);
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40383 wxPyEndAllowThreads(__tstate);
40384 if (PyErr_Occurred()) SWIG_fail;
40385 }
40386 {
40387 #if wxUSE_UNICODE
40388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40389 #else
40390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40391 #endif
40392 }
40393 return resultobj;
40394 fail:
40395 return NULL;
40396 }
40397
40398
40399 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40400 PyObject *resultobj = 0;
40401 wxMenu *arg1 = (wxMenu *) 0 ;
40402 int arg2 ;
40403 wxString *arg3 = 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 int val2 ;
40407 int ecode2 = 0 ;
40408 bool temp3 = false ;
40409 PyObject * obj0 = 0 ;
40410 PyObject * obj1 = 0 ;
40411 PyObject * obj2 = 0 ;
40412 char * kwnames[] = {
40413 (char *) "self",(char *) "id",(char *) "helpString", NULL
40414 };
40415
40416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40418 if (!SWIG_IsOK(res1)) {
40419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40420 }
40421 arg1 = reinterpret_cast< wxMenu * >(argp1);
40422 ecode2 = SWIG_AsVal_int(obj1, &val2);
40423 if (!SWIG_IsOK(ecode2)) {
40424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40425 }
40426 arg2 = static_cast< int >(val2);
40427 {
40428 arg3 = wxString_in_helper(obj2);
40429 if (arg3 == NULL) SWIG_fail;
40430 temp3 = true;
40431 }
40432 {
40433 PyThreadState* __tstate = wxPyBeginAllowThreads();
40434 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40435 wxPyEndAllowThreads(__tstate);
40436 if (PyErr_Occurred()) SWIG_fail;
40437 }
40438 resultobj = SWIG_Py_Void();
40439 {
40440 if (temp3)
40441 delete arg3;
40442 }
40443 return resultobj;
40444 fail:
40445 {
40446 if (temp3)
40447 delete arg3;
40448 }
40449 return NULL;
40450 }
40451
40452
40453 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40454 PyObject *resultobj = 0;
40455 wxMenu *arg1 = (wxMenu *) 0 ;
40456 int arg2 ;
40457 wxString result;
40458 void *argp1 = 0 ;
40459 int res1 = 0 ;
40460 int val2 ;
40461 int ecode2 = 0 ;
40462 PyObject * obj0 = 0 ;
40463 PyObject * obj1 = 0 ;
40464 char * kwnames[] = {
40465 (char *) "self",(char *) "id", NULL
40466 };
40467
40468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40470 if (!SWIG_IsOK(res1)) {
40471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40472 }
40473 arg1 = reinterpret_cast< wxMenu * >(argp1);
40474 ecode2 = SWIG_AsVal_int(obj1, &val2);
40475 if (!SWIG_IsOK(ecode2)) {
40476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40477 }
40478 arg2 = static_cast< int >(val2);
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 #if wxUSE_UNICODE
40487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40488 #else
40489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40490 #endif
40491 }
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40499 PyObject *resultobj = 0;
40500 wxMenu *arg1 = (wxMenu *) 0 ;
40501 wxString *arg2 = 0 ;
40502 void *argp1 = 0 ;
40503 int res1 = 0 ;
40504 bool temp2 = false ;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char * kwnames[] = {
40508 (char *) "self",(char *) "title", NULL
40509 };
40510
40511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40515 }
40516 arg1 = reinterpret_cast< wxMenu * >(argp1);
40517 {
40518 arg2 = wxString_in_helper(obj1);
40519 if (arg2 == NULL) SWIG_fail;
40520 temp2 = true;
40521 }
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 (arg1)->SetTitle((wxString const &)*arg2);
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 resultobj = SWIG_Py_Void();
40529 {
40530 if (temp2)
40531 delete arg2;
40532 }
40533 return resultobj;
40534 fail:
40535 {
40536 if (temp2)
40537 delete arg2;
40538 }
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40544 PyObject *resultobj = 0;
40545 wxMenu *arg1 = (wxMenu *) 0 ;
40546 wxString result;
40547 void *argp1 = 0 ;
40548 int res1 = 0 ;
40549 PyObject *swig_obj[1] ;
40550
40551 if (!args) SWIG_fail;
40552 swig_obj[0] = args;
40553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40556 }
40557 arg1 = reinterpret_cast< wxMenu * >(argp1);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 result = ((wxMenu const *)arg1)->GetTitle();
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 {
40565 #if wxUSE_UNICODE
40566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40567 #else
40568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40569 #endif
40570 }
40571 return resultobj;
40572 fail:
40573 return NULL;
40574 }
40575
40576
40577 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40578 PyObject *resultobj = 0;
40579 wxMenu *arg1 = (wxMenu *) 0 ;
40580 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40581 void *argp1 = 0 ;
40582 int res1 = 0 ;
40583 void *argp2 = 0 ;
40584 int res2 = 0 ;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char * kwnames[] = {
40588 (char *) "self",(char *) "handler", NULL
40589 };
40590
40591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40595 }
40596 arg1 = reinterpret_cast< wxMenu * >(argp1);
40597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40598 if (!SWIG_IsOK(res2)) {
40599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40600 }
40601 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40602 {
40603 PyThreadState* __tstate = wxPyBeginAllowThreads();
40604 (arg1)->SetEventHandler(arg2);
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 resultobj = SWIG_Py_Void();
40609 return resultobj;
40610 fail:
40611 return NULL;
40612 }
40613
40614
40615 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40616 PyObject *resultobj = 0;
40617 wxMenu *arg1 = (wxMenu *) 0 ;
40618 wxEvtHandler *result = 0 ;
40619 void *argp1 = 0 ;
40620 int res1 = 0 ;
40621 PyObject *swig_obj[1] ;
40622
40623 if (!args) SWIG_fail;
40624 swig_obj[0] = args;
40625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40626 if (!SWIG_IsOK(res1)) {
40627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40628 }
40629 arg1 = reinterpret_cast< wxMenu * >(argp1);
40630 {
40631 PyThreadState* __tstate = wxPyBeginAllowThreads();
40632 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40633 wxPyEndAllowThreads(__tstate);
40634 if (PyErr_Occurred()) SWIG_fail;
40635 }
40636 {
40637 resultobj = wxPyMake_wxObject(result, 0);
40638 }
40639 return resultobj;
40640 fail:
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj = 0;
40647 wxMenu *arg1 = (wxMenu *) 0 ;
40648 wxWindow *arg2 = (wxWindow *) 0 ;
40649 void *argp1 = 0 ;
40650 int res1 = 0 ;
40651 void *argp2 = 0 ;
40652 int res2 = 0 ;
40653 PyObject * obj0 = 0 ;
40654 PyObject * obj1 = 0 ;
40655 char * kwnames[] = {
40656 (char *) "self",(char *) "win", NULL
40657 };
40658
40659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40661 if (!SWIG_IsOK(res1)) {
40662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40663 }
40664 arg1 = reinterpret_cast< wxMenu * >(argp1);
40665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40666 if (!SWIG_IsOK(res2)) {
40667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40668 }
40669 arg2 = reinterpret_cast< wxWindow * >(argp2);
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 (arg1)->SetInvokingWindow(arg2);
40673 wxPyEndAllowThreads(__tstate);
40674 if (PyErr_Occurred()) SWIG_fail;
40675 }
40676 resultobj = SWIG_Py_Void();
40677 return resultobj;
40678 fail:
40679 return NULL;
40680 }
40681
40682
40683 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40684 PyObject *resultobj = 0;
40685 wxMenu *arg1 = (wxMenu *) 0 ;
40686 wxWindow *result = 0 ;
40687 void *argp1 = 0 ;
40688 int res1 = 0 ;
40689 PyObject *swig_obj[1] ;
40690
40691 if (!args) SWIG_fail;
40692 swig_obj[0] = args;
40693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40694 if (!SWIG_IsOK(res1)) {
40695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40696 }
40697 arg1 = reinterpret_cast< wxMenu * >(argp1);
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40701 wxPyEndAllowThreads(__tstate);
40702 if (PyErr_Occurred()) SWIG_fail;
40703 }
40704 {
40705 resultobj = wxPyMake_wxObject(result, 0);
40706 }
40707 return resultobj;
40708 fail:
40709 return NULL;
40710 }
40711
40712
40713 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40714 PyObject *resultobj = 0;
40715 wxMenu *arg1 = (wxMenu *) 0 ;
40716 long result;
40717 void *argp1 = 0 ;
40718 int res1 = 0 ;
40719 PyObject *swig_obj[1] ;
40720
40721 if (!args) SWIG_fail;
40722 swig_obj[0] = args;
40723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res1)) {
40725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40726 }
40727 arg1 = reinterpret_cast< wxMenu * >(argp1);
40728 {
40729 PyThreadState* __tstate = wxPyBeginAllowThreads();
40730 result = (long)((wxMenu const *)arg1)->GetStyle();
40731 wxPyEndAllowThreads(__tstate);
40732 if (PyErr_Occurred()) SWIG_fail;
40733 }
40734 resultobj = SWIG_From_long(static_cast< long >(result));
40735 return resultobj;
40736 fail:
40737 return NULL;
40738 }
40739
40740
40741 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40742 PyObject *resultobj = 0;
40743 wxMenu *arg1 = (wxMenu *) 0 ;
40744 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 void *argp2 = 0 ;
40748 int res2 = 0 ;
40749 PyObject * obj0 = 0 ;
40750 PyObject * obj1 = 0 ;
40751 char * kwnames[] = {
40752 (char *) "self",(char *) "source", NULL
40753 };
40754
40755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40757 if (!SWIG_IsOK(res1)) {
40758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40759 }
40760 arg1 = reinterpret_cast< wxMenu * >(argp1);
40761 if (obj1) {
40762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40763 if (!SWIG_IsOK(res2)) {
40764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40765 }
40766 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40767 }
40768 {
40769 PyThreadState* __tstate = wxPyBeginAllowThreads();
40770 (arg1)->UpdateUI(arg2);
40771 wxPyEndAllowThreads(__tstate);
40772 if (PyErr_Occurred()) SWIG_fail;
40773 }
40774 resultobj = SWIG_Py_Void();
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 wxMenuBar *result = 0 ;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 PyObject *swig_obj[1] ;
40788
40789 if (!args) SWIG_fail;
40790 swig_obj[0] = args;
40791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40792 if (!SWIG_IsOK(res1)) {
40793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40794 }
40795 arg1 = reinterpret_cast< wxMenu * >(argp1);
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 {
40803 resultobj = wxPyMake_wxObject(result, (bool)0);
40804 }
40805 return resultobj;
40806 fail:
40807 return NULL;
40808 }
40809
40810
40811 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj = 0;
40813 wxMenu *arg1 = (wxMenu *) 0 ;
40814 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40815 void *argp1 = 0 ;
40816 int res1 = 0 ;
40817 void *argp2 = 0 ;
40818 int res2 = 0 ;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 char * kwnames[] = {
40822 (char *) "self",(char *) "menubar", NULL
40823 };
40824
40825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40827 if (!SWIG_IsOK(res1)) {
40828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40829 }
40830 arg1 = reinterpret_cast< wxMenu * >(argp1);
40831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40832 if (!SWIG_IsOK(res2)) {
40833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40834 }
40835 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40836 {
40837 PyThreadState* __tstate = wxPyBeginAllowThreads();
40838 (arg1)->Attach(arg2);
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 resultobj = SWIG_Py_Void();
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40850 PyObject *resultobj = 0;
40851 wxMenu *arg1 = (wxMenu *) 0 ;
40852 void *argp1 = 0 ;
40853 int res1 = 0 ;
40854 PyObject *swig_obj[1] ;
40855
40856 if (!args) SWIG_fail;
40857 swig_obj[0] = args;
40858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40859 if (!SWIG_IsOK(res1)) {
40860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40861 }
40862 arg1 = reinterpret_cast< wxMenu * >(argp1);
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 (arg1)->Detach();
40866 wxPyEndAllowThreads(__tstate);
40867 if (PyErr_Occurred()) SWIG_fail;
40868 }
40869 resultobj = SWIG_Py_Void();
40870 return resultobj;
40871 fail:
40872 return NULL;
40873 }
40874
40875
40876 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40877 PyObject *resultobj = 0;
40878 wxMenu *arg1 = (wxMenu *) 0 ;
40879 bool result;
40880 void *argp1 = 0 ;
40881 int res1 = 0 ;
40882 PyObject *swig_obj[1] ;
40883
40884 if (!args) SWIG_fail;
40885 swig_obj[0] = args;
40886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40887 if (!SWIG_IsOK(res1)) {
40888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40889 }
40890 arg1 = reinterpret_cast< wxMenu * >(argp1);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (bool)((wxMenu const *)arg1)->IsAttached();
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj = 0;
40908 wxMenu *arg1 = (wxMenu *) 0 ;
40909 wxMenu *arg2 = (wxMenu *) 0 ;
40910 void *argp1 = 0 ;
40911 int res1 = 0 ;
40912 void *argp2 = 0 ;
40913 int res2 = 0 ;
40914 PyObject * obj0 = 0 ;
40915 PyObject * obj1 = 0 ;
40916 char * kwnames[] = {
40917 (char *) "self",(char *) "parent", NULL
40918 };
40919
40920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40922 if (!SWIG_IsOK(res1)) {
40923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40924 }
40925 arg1 = reinterpret_cast< wxMenu * >(argp1);
40926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40927 if (!SWIG_IsOK(res2)) {
40928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40929 }
40930 arg2 = reinterpret_cast< wxMenu * >(argp2);
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 (arg1)->SetParent(arg2);
40934 wxPyEndAllowThreads(__tstate);
40935 if (PyErr_Occurred()) SWIG_fail;
40936 }
40937 resultobj = SWIG_Py_Void();
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40945 PyObject *resultobj = 0;
40946 wxMenu *arg1 = (wxMenu *) 0 ;
40947 wxMenu *result = 0 ;
40948 void *argp1 = 0 ;
40949 int res1 = 0 ;
40950 PyObject *swig_obj[1] ;
40951
40952 if (!args) SWIG_fail;
40953 swig_obj[0] = args;
40954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40957 }
40958 arg1 = reinterpret_cast< wxMenu * >(argp1);
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 {
40966 resultobj = wxPyMake_wxObject(result, 0);
40967 }
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40975 PyObject *obj;
40976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40977 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40978 return SWIG_Py_Void();
40979 }
40980
40981 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40982 return SWIG_Python_InitShadowInstance(args);
40983 }
40984
40985 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40986 PyObject *resultobj = 0;
40987 long arg1 = (long) 0 ;
40988 wxMenuBar *result = 0 ;
40989 long val1 ;
40990 int ecode1 = 0 ;
40991 PyObject * obj0 = 0 ;
40992 char * kwnames[] = {
40993 (char *) "style", NULL
40994 };
40995
40996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40997 if (obj0) {
40998 ecode1 = SWIG_AsVal_long(obj0, &val1);
40999 if (!SWIG_IsOK(ecode1)) {
41000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41001 }
41002 arg1 = static_cast< long >(val1);
41003 }
41004 {
41005 if (!wxPyCheckForApp()) SWIG_fail;
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (wxMenuBar *)new wxMenuBar(arg1);
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41012 return resultobj;
41013 fail:
41014 return NULL;
41015 }
41016
41017
41018 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41019 PyObject *resultobj = 0;
41020 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41021 wxMenu *arg2 = (wxMenu *) 0 ;
41022 wxString *arg3 = 0 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 void *argp2 = 0 ;
41027 int res2 = 0 ;
41028 bool temp3 = false ;
41029 PyObject * obj0 = 0 ;
41030 PyObject * obj1 = 0 ;
41031 PyObject * obj2 = 0 ;
41032 char * kwnames[] = {
41033 (char *) "self",(char *) "menu",(char *) "title", NULL
41034 };
41035
41036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41038 if (!SWIG_IsOK(res1)) {
41039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41040 }
41041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41043 if (!SWIG_IsOK(res2)) {
41044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41045 }
41046 arg2 = reinterpret_cast< wxMenu * >(argp2);
41047 {
41048 arg3 = wxString_in_helper(obj2);
41049 if (arg3 == NULL) SWIG_fail;
41050 temp3 = true;
41051 }
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 {
41059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41060 }
41061 {
41062 if (temp3)
41063 delete arg3;
41064 }
41065 return resultobj;
41066 fail:
41067 {
41068 if (temp3)
41069 delete arg3;
41070 }
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj = 0;
41077 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41078 size_t arg2 ;
41079 wxMenu *arg3 = (wxMenu *) 0 ;
41080 wxString *arg4 = 0 ;
41081 bool result;
41082 void *argp1 = 0 ;
41083 int res1 = 0 ;
41084 size_t val2 ;
41085 int ecode2 = 0 ;
41086 void *argp3 = 0 ;
41087 int res3 = 0 ;
41088 bool temp4 = false ;
41089 PyObject * obj0 = 0 ;
41090 PyObject * obj1 = 0 ;
41091 PyObject * obj2 = 0 ;
41092 PyObject * obj3 = 0 ;
41093 char * kwnames[] = {
41094 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41095 };
41096
41097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41099 if (!SWIG_IsOK(res1)) {
41100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41101 }
41102 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41103 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41104 if (!SWIG_IsOK(ecode2)) {
41105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41106 }
41107 arg2 = static_cast< size_t >(val2);
41108 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41109 if (!SWIG_IsOK(res3)) {
41110 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41111 }
41112 arg3 = reinterpret_cast< wxMenu * >(argp3);
41113 {
41114 arg4 = wxString_in_helper(obj3);
41115 if (arg4 == NULL) SWIG_fail;
41116 temp4 = true;
41117 }
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 {
41125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41126 }
41127 {
41128 if (temp4)
41129 delete arg4;
41130 }
41131 return resultobj;
41132 fail:
41133 {
41134 if (temp4)
41135 delete arg4;
41136 }
41137 return NULL;
41138 }
41139
41140
41141 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41142 PyObject *resultobj = 0;
41143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41144 size_t result;
41145 void *argp1 = 0 ;
41146 int res1 = 0 ;
41147 PyObject *swig_obj[1] ;
41148
41149 if (!args) SWIG_fail;
41150 swig_obj[0] = args;
41151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41152 if (!SWIG_IsOK(res1)) {
41153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41154 }
41155 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41156 {
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj = 0;
41171 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41172 size_t arg2 ;
41173 wxMenu *result = 0 ;
41174 void *argp1 = 0 ;
41175 int res1 = 0 ;
41176 size_t val2 ;
41177 int ecode2 = 0 ;
41178 PyObject * obj0 = 0 ;
41179 PyObject * obj1 = 0 ;
41180 char * kwnames[] = {
41181 (char *) "self",(char *) "pos", NULL
41182 };
41183
41184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41186 if (!SWIG_IsOK(res1)) {
41187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41188 }
41189 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41190 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41191 if (!SWIG_IsOK(ecode2)) {
41192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41193 }
41194 arg2 = static_cast< size_t >(val2);
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 {
41202 resultobj = wxPyMake_wxObject(result, 0);
41203 }
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41211 PyObject *resultobj = 0;
41212 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41213 size_t arg2 ;
41214 wxMenu *arg3 = (wxMenu *) 0 ;
41215 wxString *arg4 = 0 ;
41216 wxMenu *result = 0 ;
41217 void *argp1 = 0 ;
41218 int res1 = 0 ;
41219 size_t val2 ;
41220 int ecode2 = 0 ;
41221 void *argp3 = 0 ;
41222 int res3 = 0 ;
41223 bool temp4 = false ;
41224 PyObject * obj0 = 0 ;
41225 PyObject * obj1 = 0 ;
41226 PyObject * obj2 = 0 ;
41227 PyObject * obj3 = 0 ;
41228 char * kwnames[] = {
41229 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41230 };
41231
41232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41234 if (!SWIG_IsOK(res1)) {
41235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41236 }
41237 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41238 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41239 if (!SWIG_IsOK(ecode2)) {
41240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41241 }
41242 arg2 = static_cast< size_t >(val2);
41243 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41244 if (!SWIG_IsOK(res3)) {
41245 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41246 }
41247 arg3 = reinterpret_cast< wxMenu * >(argp3);
41248 {
41249 arg4 = wxString_in_helper(obj3);
41250 if (arg4 == NULL) SWIG_fail;
41251 temp4 = true;
41252 }
41253 {
41254 PyThreadState* __tstate = wxPyBeginAllowThreads();
41255 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41256 wxPyEndAllowThreads(__tstate);
41257 if (PyErr_Occurred()) SWIG_fail;
41258 }
41259 {
41260 resultobj = wxPyMake_wxObject(result, 0);
41261 }
41262 {
41263 if (temp4)
41264 delete arg4;
41265 }
41266 return resultobj;
41267 fail:
41268 {
41269 if (temp4)
41270 delete arg4;
41271 }
41272 return NULL;
41273 }
41274
41275
41276 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41277 PyObject *resultobj = 0;
41278 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41279 size_t arg2 ;
41280 wxMenu *result = 0 ;
41281 void *argp1 = 0 ;
41282 int res1 = 0 ;
41283 size_t val2 ;
41284 int ecode2 = 0 ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 char * kwnames[] = {
41288 (char *) "self",(char *) "pos", NULL
41289 };
41290
41291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41293 if (!SWIG_IsOK(res1)) {
41294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41295 }
41296 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41298 if (!SWIG_IsOK(ecode2)) {
41299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41300 }
41301 arg2 = static_cast< size_t >(val2);
41302 {
41303 PyThreadState* __tstate = wxPyBeginAllowThreads();
41304 result = (wxMenu *)(arg1)->Remove(arg2);
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 {
41309 resultobj = wxPyMake_wxObject(result, 0);
41310 }
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41318 PyObject *resultobj = 0;
41319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41320 size_t arg2 ;
41321 bool arg3 ;
41322 void *argp1 = 0 ;
41323 int res1 = 0 ;
41324 size_t val2 ;
41325 int ecode2 = 0 ;
41326 bool val3 ;
41327 int ecode3 = 0 ;
41328 PyObject * obj0 = 0 ;
41329 PyObject * obj1 = 0 ;
41330 PyObject * obj2 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos",(char *) "enable", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41339 }
41340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41341 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41342 if (!SWIG_IsOK(ecode2)) {
41343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41347 if (!SWIG_IsOK(ecode3)) {
41348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41349 }
41350 arg3 = static_cast< bool >(val3);
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 (arg1)->EnableTop(arg2,arg3);
41354 wxPyEndAllowThreads(__tstate);
41355 if (PyErr_Occurred()) SWIG_fail;
41356 }
41357 resultobj = SWIG_Py_Void();
41358 return resultobj;
41359 fail:
41360 return NULL;
41361 }
41362
41363
41364 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41365 PyObject *resultobj = 0;
41366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41367 size_t arg2 ;
41368 bool result;
41369 void *argp1 = 0 ;
41370 int res1 = 0 ;
41371 size_t val2 ;
41372 int ecode2 = 0 ;
41373 PyObject * obj0 = 0 ;
41374 PyObject * obj1 = 0 ;
41375 char * kwnames[] = {
41376 (char *) "self",(char *) "pos", NULL
41377 };
41378
41379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41386 if (!SWIG_IsOK(ecode2)) {
41387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41388 }
41389 arg2 = static_cast< size_t >(val2);
41390 {
41391 PyThreadState* __tstate = wxPyBeginAllowThreads();
41392 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41393 wxPyEndAllowThreads(__tstate);
41394 if (PyErr_Occurred()) SWIG_fail;
41395 }
41396 {
41397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41398 }
41399 return resultobj;
41400 fail:
41401 return NULL;
41402 }
41403
41404
41405 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41406 PyObject *resultobj = 0;
41407 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41408 size_t arg2 ;
41409 wxString *arg3 = 0 ;
41410 void *argp1 = 0 ;
41411 int res1 = 0 ;
41412 size_t val2 ;
41413 int ecode2 = 0 ;
41414 bool temp3 = false ;
41415 PyObject * obj0 = 0 ;
41416 PyObject * obj1 = 0 ;
41417 PyObject * obj2 = 0 ;
41418 char * kwnames[] = {
41419 (char *) "self",(char *) "pos",(char *) "label", NULL
41420 };
41421
41422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41424 if (!SWIG_IsOK(res1)) {
41425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41426 }
41427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41429 if (!SWIG_IsOK(ecode2)) {
41430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41431 }
41432 arg2 = static_cast< size_t >(val2);
41433 {
41434 arg3 = wxString_in_helper(obj2);
41435 if (arg3 == NULL) SWIG_fail;
41436 temp3 = true;
41437 }
41438 {
41439 PyThreadState* __tstate = wxPyBeginAllowThreads();
41440 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41441 wxPyEndAllowThreads(__tstate);
41442 if (PyErr_Occurred()) SWIG_fail;
41443 }
41444 resultobj = SWIG_Py_Void();
41445 {
41446 if (temp3)
41447 delete arg3;
41448 }
41449 return resultobj;
41450 fail:
41451 {
41452 if (temp3)
41453 delete arg3;
41454 }
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41460 PyObject *resultobj = 0;
41461 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41462 size_t arg2 ;
41463 wxString result;
41464 void *argp1 = 0 ;
41465 int res1 = 0 ;
41466 size_t val2 ;
41467 int ecode2 = 0 ;
41468 PyObject * obj0 = 0 ;
41469 PyObject * obj1 = 0 ;
41470 char * kwnames[] = {
41471 (char *) "self",(char *) "pos", NULL
41472 };
41473
41474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41476 if (!SWIG_IsOK(res1)) {
41477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41478 }
41479 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41481 if (!SWIG_IsOK(ecode2)) {
41482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41483 }
41484 arg2 = static_cast< size_t >(val2);
41485 {
41486 PyThreadState* __tstate = wxPyBeginAllowThreads();
41487 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41488 wxPyEndAllowThreads(__tstate);
41489 if (PyErr_Occurred()) SWIG_fail;
41490 }
41491 {
41492 #if wxUSE_UNICODE
41493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41494 #else
41495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41496 #endif
41497 }
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj = 0;
41506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41507 wxString *arg2 = 0 ;
41508 wxString *arg3 = 0 ;
41509 int result;
41510 void *argp1 = 0 ;
41511 int res1 = 0 ;
41512 bool temp2 = false ;
41513 bool temp3 = false ;
41514 PyObject * obj0 = 0 ;
41515 PyObject * obj1 = 0 ;
41516 PyObject * obj2 = 0 ;
41517 char * kwnames[] = {
41518 (char *) "self",(char *) "menu",(char *) "item", NULL
41519 };
41520
41521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41523 if (!SWIG_IsOK(res1)) {
41524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41525 }
41526 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41527 {
41528 arg2 = wxString_in_helper(obj1);
41529 if (arg2 == NULL) SWIG_fail;
41530 temp2 = true;
41531 }
41532 {
41533 arg3 = wxString_in_helper(obj2);
41534 if (arg3 == NULL) SWIG_fail;
41535 temp3 = true;
41536 }
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41540 wxPyEndAllowThreads(__tstate);
41541 if (PyErr_Occurred()) SWIG_fail;
41542 }
41543 resultobj = SWIG_From_int(static_cast< int >(result));
41544 {
41545 if (temp2)
41546 delete arg2;
41547 }
41548 {
41549 if (temp3)
41550 delete arg3;
41551 }
41552 return resultobj;
41553 fail:
41554 {
41555 if (temp2)
41556 delete arg2;
41557 }
41558 {
41559 if (temp3)
41560 delete arg3;
41561 }
41562 return NULL;
41563 }
41564
41565
41566 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41567 PyObject *resultobj = 0;
41568 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41569 int arg2 ;
41570 wxMenuItem *result = 0 ;
41571 void *argp1 = 0 ;
41572 int res1 = 0 ;
41573 int val2 ;
41574 int ecode2 = 0 ;
41575 PyObject * obj0 = 0 ;
41576 PyObject * obj1 = 0 ;
41577 char * kwnames[] = {
41578 (char *) "self",(char *) "id", NULL
41579 };
41580
41581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41583 if (!SWIG_IsOK(res1)) {
41584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41585 }
41586 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41587 ecode2 = SWIG_AsVal_int(obj1, &val2);
41588 if (!SWIG_IsOK(ecode2)) {
41589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41590 }
41591 arg2 = static_cast< int >(val2);
41592 {
41593 PyThreadState* __tstate = wxPyBeginAllowThreads();
41594 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 {
41599 resultobj = wxPyMake_wxObject(result, (bool)0);
41600 }
41601 return resultobj;
41602 fail:
41603 return NULL;
41604 }
41605
41606
41607 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41608 PyObject *resultobj = 0;
41609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41610 wxString *arg2 = 0 ;
41611 int result;
41612 void *argp1 = 0 ;
41613 int res1 = 0 ;
41614 bool temp2 = false ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char * kwnames[] = {
41618 (char *) "self",(char *) "title", NULL
41619 };
41620
41621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41623 if (!SWIG_IsOK(res1)) {
41624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41625 }
41626 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41627 {
41628 arg2 = wxString_in_helper(obj1);
41629 if (arg2 == NULL) SWIG_fail;
41630 temp2 = true;
41631 }
41632 {
41633 PyThreadState* __tstate = wxPyBeginAllowThreads();
41634 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41635 wxPyEndAllowThreads(__tstate);
41636 if (PyErr_Occurred()) SWIG_fail;
41637 }
41638 resultobj = SWIG_From_int(static_cast< int >(result));
41639 {
41640 if (temp2)
41641 delete arg2;
41642 }
41643 return resultobj;
41644 fail:
41645 {
41646 if (temp2)
41647 delete arg2;
41648 }
41649 return NULL;
41650 }
41651
41652
41653 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj = 0;
41655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41656 int arg2 ;
41657 bool arg3 ;
41658 void *argp1 = 0 ;
41659 int res1 = 0 ;
41660 int val2 ;
41661 int ecode2 = 0 ;
41662 bool val3 ;
41663 int ecode3 = 0 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 PyObject * obj2 = 0 ;
41667 char * kwnames[] = {
41668 (char *) "self",(char *) "id",(char *) "enable", NULL
41669 };
41670
41671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41673 if (!SWIG_IsOK(res1)) {
41674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41675 }
41676 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41677 ecode2 = SWIG_AsVal_int(obj1, &val2);
41678 if (!SWIG_IsOK(ecode2)) {
41679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41680 }
41681 arg2 = static_cast< int >(val2);
41682 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41683 if (!SWIG_IsOK(ecode3)) {
41684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41685 }
41686 arg3 = static_cast< bool >(val3);
41687 {
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 (arg1)->Enable(arg2,arg3);
41690 wxPyEndAllowThreads(__tstate);
41691 if (PyErr_Occurred()) SWIG_fail;
41692 }
41693 resultobj = SWIG_Py_Void();
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj = 0;
41702 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41703 int arg2 ;
41704 bool arg3 ;
41705 void *argp1 = 0 ;
41706 int res1 = 0 ;
41707 int val2 ;
41708 int ecode2 = 0 ;
41709 bool val3 ;
41710 int ecode3 = 0 ;
41711 PyObject * obj0 = 0 ;
41712 PyObject * obj1 = 0 ;
41713 PyObject * obj2 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "id",(char *) "check", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41722 }
41723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41724 ecode2 = SWIG_AsVal_int(obj1, &val2);
41725 if (!SWIG_IsOK(ecode2)) {
41726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41727 }
41728 arg2 = static_cast< int >(val2);
41729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41730 if (!SWIG_IsOK(ecode3)) {
41731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41732 }
41733 arg3 = static_cast< bool >(val3);
41734 {
41735 PyThreadState* __tstate = wxPyBeginAllowThreads();
41736 (arg1)->Check(arg2,arg3);
41737 wxPyEndAllowThreads(__tstate);
41738 if (PyErr_Occurred()) SWIG_fail;
41739 }
41740 resultobj = SWIG_Py_Void();
41741 return resultobj;
41742 fail:
41743 return NULL;
41744 }
41745
41746
41747 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41748 PyObject *resultobj = 0;
41749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41750 int arg2 ;
41751 bool result;
41752 void *argp1 = 0 ;
41753 int res1 = 0 ;
41754 int val2 ;
41755 int ecode2 = 0 ;
41756 PyObject * obj0 = 0 ;
41757 PyObject * obj1 = 0 ;
41758 char * kwnames[] = {
41759 (char *) "self",(char *) "id", NULL
41760 };
41761
41762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41764 if (!SWIG_IsOK(res1)) {
41765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41766 }
41767 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41768 ecode2 = SWIG_AsVal_int(obj1, &val2);
41769 if (!SWIG_IsOK(ecode2)) {
41770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41771 }
41772 arg2 = static_cast< int >(val2);
41773 {
41774 PyThreadState* __tstate = wxPyBeginAllowThreads();
41775 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41776 wxPyEndAllowThreads(__tstate);
41777 if (PyErr_Occurred()) SWIG_fail;
41778 }
41779 {
41780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41781 }
41782 return resultobj;
41783 fail:
41784 return NULL;
41785 }
41786
41787
41788 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41789 PyObject *resultobj = 0;
41790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41791 int arg2 ;
41792 bool result;
41793 void *argp1 = 0 ;
41794 int res1 = 0 ;
41795 int val2 ;
41796 int ecode2 = 0 ;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799 char * kwnames[] = {
41800 (char *) "self",(char *) "id", NULL
41801 };
41802
41803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41805 if (!SWIG_IsOK(res1)) {
41806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41807 }
41808 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41809 ecode2 = SWIG_AsVal_int(obj1, &val2);
41810 if (!SWIG_IsOK(ecode2)) {
41811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41812 }
41813 arg2 = static_cast< int >(val2);
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 {
41821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41822 }
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj = 0;
41831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41832 int arg2 ;
41833 wxString *arg3 = 0 ;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 int val2 ;
41837 int ecode2 = 0 ;
41838 bool temp3 = false ;
41839 PyObject * obj0 = 0 ;
41840 PyObject * obj1 = 0 ;
41841 PyObject * obj2 = 0 ;
41842 char * kwnames[] = {
41843 (char *) "self",(char *) "id",(char *) "label", NULL
41844 };
41845
41846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41848 if (!SWIG_IsOK(res1)) {
41849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41850 }
41851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41852 ecode2 = SWIG_AsVal_int(obj1, &val2);
41853 if (!SWIG_IsOK(ecode2)) {
41854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41855 }
41856 arg2 = static_cast< int >(val2);
41857 {
41858 arg3 = wxString_in_helper(obj2);
41859 if (arg3 == NULL) SWIG_fail;
41860 temp3 = true;
41861 }
41862 {
41863 PyThreadState* __tstate = wxPyBeginAllowThreads();
41864 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 resultobj = SWIG_Py_Void();
41869 {
41870 if (temp3)
41871 delete arg3;
41872 }
41873 return resultobj;
41874 fail:
41875 {
41876 if (temp3)
41877 delete arg3;
41878 }
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj = 0;
41885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41886 int arg2 ;
41887 wxString result;
41888 void *argp1 = 0 ;
41889 int res1 = 0 ;
41890 int val2 ;
41891 int ecode2 = 0 ;
41892 PyObject * obj0 = 0 ;
41893 PyObject * obj1 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "self",(char *) "id", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41904 ecode2 = SWIG_AsVal_int(obj1, &val2);
41905 if (!SWIG_IsOK(ecode2)) {
41906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41907 }
41908 arg2 = static_cast< int >(val2);
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 #if wxUSE_UNICODE
41917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41918 #else
41919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41920 #endif
41921 }
41922 return resultobj;
41923 fail:
41924 return NULL;
41925 }
41926
41927
41928 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41929 PyObject *resultobj = 0;
41930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41931 int arg2 ;
41932 wxString *arg3 = 0 ;
41933 void *argp1 = 0 ;
41934 int res1 = 0 ;
41935 int val2 ;
41936 int ecode2 = 0 ;
41937 bool temp3 = false ;
41938 PyObject * obj0 = 0 ;
41939 PyObject * obj1 = 0 ;
41940 PyObject * obj2 = 0 ;
41941 char * kwnames[] = {
41942 (char *) "self",(char *) "id",(char *) "helpString", NULL
41943 };
41944
41945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41947 if (!SWIG_IsOK(res1)) {
41948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41949 }
41950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41951 ecode2 = SWIG_AsVal_int(obj1, &val2);
41952 if (!SWIG_IsOK(ecode2)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41954 }
41955 arg2 = static_cast< int >(val2);
41956 {
41957 arg3 = wxString_in_helper(obj2);
41958 if (arg3 == NULL) SWIG_fail;
41959 temp3 = true;
41960 }
41961 {
41962 PyThreadState* __tstate = wxPyBeginAllowThreads();
41963 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41964 wxPyEndAllowThreads(__tstate);
41965 if (PyErr_Occurred()) SWIG_fail;
41966 }
41967 resultobj = SWIG_Py_Void();
41968 {
41969 if (temp3)
41970 delete arg3;
41971 }
41972 return resultobj;
41973 fail:
41974 {
41975 if (temp3)
41976 delete arg3;
41977 }
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj = 0;
41984 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41985 int arg2 ;
41986 wxString result;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 int val2 ;
41990 int ecode2 = 0 ;
41991 PyObject * obj0 = 0 ;
41992 PyObject * obj1 = 0 ;
41993 char * kwnames[] = {
41994 (char *) "self",(char *) "id", NULL
41995 };
41996
41997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41999 if (!SWIG_IsOK(res1)) {
42000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42001 }
42002 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42003 ecode2 = SWIG_AsVal_int(obj1, &val2);
42004 if (!SWIG_IsOK(ecode2)) {
42005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42006 }
42007 arg2 = static_cast< int >(val2);
42008 {
42009 PyThreadState* __tstate = wxPyBeginAllowThreads();
42010 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42011 wxPyEndAllowThreads(__tstate);
42012 if (PyErr_Occurred()) SWIG_fail;
42013 }
42014 {
42015 #if wxUSE_UNICODE
42016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42017 #else
42018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42019 #endif
42020 }
42021 return resultobj;
42022 fail:
42023 return NULL;
42024 }
42025
42026
42027 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42028 PyObject *resultobj = 0;
42029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42030 wxFrame *result = 0 ;
42031 void *argp1 = 0 ;
42032 int res1 = 0 ;
42033 PyObject *swig_obj[1] ;
42034
42035 if (!args) SWIG_fail;
42036 swig_obj[0] = args;
42037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42038 if (!SWIG_IsOK(res1)) {
42039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42040 }
42041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 {
42049 resultobj = wxPyMake_wxObject(result, (bool)0);
42050 }
42051 return resultobj;
42052 fail:
42053 return NULL;
42054 }
42055
42056
42057 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42058 PyObject *resultobj = 0;
42059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42060 bool result;
42061 void *argp1 = 0 ;
42062 int res1 = 0 ;
42063 PyObject *swig_obj[1] ;
42064
42065 if (!args) SWIG_fail;
42066 swig_obj[0] = args;
42067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42068 if (!SWIG_IsOK(res1)) {
42069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42070 }
42071 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 {
42079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42080 }
42081 return resultobj;
42082 fail:
42083 return NULL;
42084 }
42085
42086
42087 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42088 PyObject *resultobj = 0;
42089 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42090 wxFrame *arg2 = (wxFrame *) 0 ;
42091 void *argp1 = 0 ;
42092 int res1 = 0 ;
42093 void *argp2 = 0 ;
42094 int res2 = 0 ;
42095 PyObject * obj0 = 0 ;
42096 PyObject * obj1 = 0 ;
42097 char * kwnames[] = {
42098 (char *) "self",(char *) "frame", NULL
42099 };
42100
42101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42103 if (!SWIG_IsOK(res1)) {
42104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42105 }
42106 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42108 if (!SWIG_IsOK(res2)) {
42109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42110 }
42111 arg2 = reinterpret_cast< wxFrame * >(argp2);
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 (arg1)->Attach(arg2);
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 resultobj = SWIG_Py_Void();
42119 return resultobj;
42120 fail:
42121 return NULL;
42122 }
42123
42124
42125 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42126 PyObject *resultobj = 0;
42127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42128 void *argp1 = 0 ;
42129 int res1 = 0 ;
42130 PyObject *swig_obj[1] ;
42131
42132 if (!args) SWIG_fail;
42133 swig_obj[0] = args;
42134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42135 if (!SWIG_IsOK(res1)) {
42136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42137 }
42138 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 (arg1)->Detach();
42142 wxPyEndAllowThreads(__tstate);
42143 if (PyErr_Occurred()) SWIG_fail;
42144 }
42145 resultobj = SWIG_Py_Void();
42146 return resultobj;
42147 fail:
42148 return NULL;
42149 }
42150
42151
42152 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42153 PyObject *resultobj = 0;
42154 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42155 void *argp1 = 0 ;
42156 int res1 = 0 ;
42157 PyObject *swig_obj[1] ;
42158
42159 if (!args) SWIG_fail;
42160 swig_obj[0] = args;
42161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42162 if (!SWIG_IsOK(res1)) {
42163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42164 }
42165 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42166 {
42167 PyThreadState* __tstate = wxPyBeginAllowThreads();
42168 (arg1)->UpdateMenus();
42169 wxPyEndAllowThreads(__tstate);
42170 if (PyErr_Occurred()) SWIG_fail;
42171 }
42172 resultobj = SWIG_Py_Void();
42173 return resultobj;
42174 fail:
42175 return NULL;
42176 }
42177
42178
42179 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42180 PyObject *resultobj = 0;
42181 bool arg1 ;
42182 bool val1 ;
42183 int ecode1 = 0 ;
42184 PyObject * obj0 = 0 ;
42185 char * kwnames[] = {
42186 (char *) "enable", NULL
42187 };
42188
42189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42190 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42191 if (!SWIG_IsOK(ecode1)) {
42192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42193 }
42194 arg1 = static_cast< bool >(val1);
42195 {
42196 PyThreadState* __tstate = wxPyBeginAllowThreads();
42197 wxMenuBar::SetAutoWindowMenu(arg1);
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 resultobj = SWIG_Py_Void();
42202 return resultobj;
42203 fail:
42204 return NULL;
42205 }
42206
42207
42208 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42209 PyObject *resultobj = 0;
42210 bool result;
42211
42212 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42213 {
42214 PyThreadState* __tstate = wxPyBeginAllowThreads();
42215 result = (bool)wxMenuBar::GetAutoWindowMenu();
42216 wxPyEndAllowThreads(__tstate);
42217 if (PyErr_Occurred()) SWIG_fail;
42218 }
42219 {
42220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42221 }
42222 return resultobj;
42223 fail:
42224 return NULL;
42225 }
42226
42227
42228 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42229 PyObject *obj;
42230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42231 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42232 return SWIG_Py_Void();
42233 }
42234
42235 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42236 return SWIG_Python_InitShadowInstance(args);
42237 }
42238
42239 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42240 PyObject *resultobj = 0;
42241 wxMenu *arg1 = (wxMenu *) NULL ;
42242 int arg2 = (int) wxID_ANY ;
42243 wxString const &arg3_defvalue = wxPyEmptyString ;
42244 wxString *arg3 = (wxString *) &arg3_defvalue ;
42245 wxString const &arg4_defvalue = wxPyEmptyString ;
42246 wxString *arg4 = (wxString *) &arg4_defvalue ;
42247 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42248 wxMenu *arg6 = (wxMenu *) NULL ;
42249 wxMenuItem *result = 0 ;
42250 void *argp1 = 0 ;
42251 int res1 = 0 ;
42252 int val2 ;
42253 int ecode2 = 0 ;
42254 bool temp3 = false ;
42255 bool temp4 = false ;
42256 int val5 ;
42257 int ecode5 = 0 ;
42258 void *argp6 = 0 ;
42259 int res6 = 0 ;
42260 PyObject * obj0 = 0 ;
42261 PyObject * obj1 = 0 ;
42262 PyObject * obj2 = 0 ;
42263 PyObject * obj3 = 0 ;
42264 PyObject * obj4 = 0 ;
42265 PyObject * obj5 = 0 ;
42266 char * kwnames[] = {
42267 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42268 };
42269
42270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42271 if (obj0) {
42272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42273 if (!SWIG_IsOK(res1)) {
42274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42275 }
42276 arg1 = reinterpret_cast< wxMenu * >(argp1);
42277 }
42278 if (obj1) {
42279 ecode2 = SWIG_AsVal_int(obj1, &val2);
42280 if (!SWIG_IsOK(ecode2)) {
42281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42282 }
42283 arg2 = static_cast< int >(val2);
42284 }
42285 if (obj2) {
42286 {
42287 arg3 = wxString_in_helper(obj2);
42288 if (arg3 == NULL) SWIG_fail;
42289 temp3 = true;
42290 }
42291 }
42292 if (obj3) {
42293 {
42294 arg4 = wxString_in_helper(obj3);
42295 if (arg4 == NULL) SWIG_fail;
42296 temp4 = true;
42297 }
42298 }
42299 if (obj4) {
42300 ecode5 = SWIG_AsVal_int(obj4, &val5);
42301 if (!SWIG_IsOK(ecode5)) {
42302 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42303 }
42304 arg5 = static_cast< wxItemKind >(val5);
42305 }
42306 if (obj5) {
42307 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42308 if (!SWIG_IsOK(res6)) {
42309 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42310 }
42311 arg6 = reinterpret_cast< wxMenu * >(argp6);
42312 }
42313 {
42314 PyThreadState* __tstate = wxPyBeginAllowThreads();
42315 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42316 wxPyEndAllowThreads(__tstate);
42317 if (PyErr_Occurred()) SWIG_fail;
42318 }
42319 {
42320 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42321 }
42322 {
42323 if (temp3)
42324 delete arg3;
42325 }
42326 {
42327 if (temp4)
42328 delete arg4;
42329 }
42330 return resultobj;
42331 fail:
42332 {
42333 if (temp3)
42334 delete arg3;
42335 }
42336 {
42337 if (temp4)
42338 delete arg4;
42339 }
42340 return NULL;
42341 }
42342
42343
42344 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42345 PyObject *resultobj = 0;
42346 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42347 void *argp1 = 0 ;
42348 int res1 = 0 ;
42349 PyObject *swig_obj[1] ;
42350
42351 if (!args) SWIG_fail;
42352 swig_obj[0] = args;
42353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42354 if (!SWIG_IsOK(res1)) {
42355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42356 }
42357 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42358 {
42359 PyThreadState* __tstate = wxPyBeginAllowThreads();
42360 delete arg1;
42361
42362 wxPyEndAllowThreads(__tstate);
42363 if (PyErr_Occurred()) SWIG_fail;
42364 }
42365 resultobj = SWIG_Py_Void();
42366 return resultobj;
42367 fail:
42368 return NULL;
42369 }
42370
42371
42372 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42373 PyObject *resultobj = 0;
42374 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42375 wxMenu *result = 0 ;
42376 void *argp1 = 0 ;
42377 int res1 = 0 ;
42378 PyObject *swig_obj[1] ;
42379
42380 if (!args) SWIG_fail;
42381 swig_obj[0] = args;
42382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42383 if (!SWIG_IsOK(res1)) {
42384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42385 }
42386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42387 {
42388 PyThreadState* __tstate = wxPyBeginAllowThreads();
42389 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 {
42394 resultobj = wxPyMake_wxObject(result, 0);
42395 }
42396 return resultobj;
42397 fail:
42398 return NULL;
42399 }
42400
42401
42402 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42403 PyObject *resultobj = 0;
42404 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42405 wxMenu *arg2 = (wxMenu *) 0 ;
42406 void *argp1 = 0 ;
42407 int res1 = 0 ;
42408 void *argp2 = 0 ;
42409 int res2 = 0 ;
42410 PyObject * obj0 = 0 ;
42411 PyObject * obj1 = 0 ;
42412 char * kwnames[] = {
42413 (char *) "self",(char *) "menu", NULL
42414 };
42415
42416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42418 if (!SWIG_IsOK(res1)) {
42419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42420 }
42421 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42423 if (!SWIG_IsOK(res2)) {
42424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42425 }
42426 arg2 = reinterpret_cast< wxMenu * >(argp2);
42427 {
42428 PyThreadState* __tstate = wxPyBeginAllowThreads();
42429 (arg1)->SetMenu(arg2);
42430 wxPyEndAllowThreads(__tstate);
42431 if (PyErr_Occurred()) SWIG_fail;
42432 }
42433 resultobj = SWIG_Py_Void();
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42441 PyObject *resultobj = 0;
42442 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42443 int arg2 ;
42444 void *argp1 = 0 ;
42445 int res1 = 0 ;
42446 int val2 ;
42447 int ecode2 = 0 ;
42448 PyObject * obj0 = 0 ;
42449 PyObject * obj1 = 0 ;
42450 char * kwnames[] = {
42451 (char *) "self",(char *) "id", NULL
42452 };
42453
42454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42456 if (!SWIG_IsOK(res1)) {
42457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42458 }
42459 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42460 ecode2 = SWIG_AsVal_int(obj1, &val2);
42461 if (!SWIG_IsOK(ecode2)) {
42462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42463 }
42464 arg2 = static_cast< int >(val2);
42465 {
42466 PyThreadState* __tstate = wxPyBeginAllowThreads();
42467 (arg1)->SetId(arg2);
42468 wxPyEndAllowThreads(__tstate);
42469 if (PyErr_Occurred()) SWIG_fail;
42470 }
42471 resultobj = SWIG_Py_Void();
42472 return resultobj;
42473 fail:
42474 return NULL;
42475 }
42476
42477
42478 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42479 PyObject *resultobj = 0;
42480 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42481 int result;
42482 void *argp1 = 0 ;
42483 int res1 = 0 ;
42484 PyObject *swig_obj[1] ;
42485
42486 if (!args) SWIG_fail;
42487 swig_obj[0] = args;
42488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42489 if (!SWIG_IsOK(res1)) {
42490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42491 }
42492 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42493 {
42494 PyThreadState* __tstate = wxPyBeginAllowThreads();
42495 result = (int)((wxMenuItem const *)arg1)->GetId();
42496 wxPyEndAllowThreads(__tstate);
42497 if (PyErr_Occurred()) SWIG_fail;
42498 }
42499 resultobj = SWIG_From_int(static_cast< int >(result));
42500 return resultobj;
42501 fail:
42502 return NULL;
42503 }
42504
42505
42506 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42507 PyObject *resultobj = 0;
42508 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42509 bool result;
42510 void *argp1 = 0 ;
42511 int res1 = 0 ;
42512 PyObject *swig_obj[1] ;
42513
42514 if (!args) SWIG_fail;
42515 swig_obj[0] = args;
42516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42517 if (!SWIG_IsOK(res1)) {
42518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42519 }
42520 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42521 {
42522 PyThreadState* __tstate = wxPyBeginAllowThreads();
42523 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42524 wxPyEndAllowThreads(__tstate);
42525 if (PyErr_Occurred()) SWIG_fail;
42526 }
42527 {
42528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42529 }
42530 return resultobj;
42531 fail:
42532 return NULL;
42533 }
42534
42535
42536 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42537 PyObject *resultobj = 0;
42538 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42539 wxString *arg2 = 0 ;
42540 void *argp1 = 0 ;
42541 int res1 = 0 ;
42542 bool temp2 = false ;
42543 PyObject * obj0 = 0 ;
42544 PyObject * obj1 = 0 ;
42545 char * kwnames[] = {
42546 (char *) "self",(char *) "str", NULL
42547 };
42548
42549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42551 if (!SWIG_IsOK(res1)) {
42552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42553 }
42554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42555 {
42556 arg2 = wxString_in_helper(obj1);
42557 if (arg2 == NULL) SWIG_fail;
42558 temp2 = true;
42559 }
42560 {
42561 PyThreadState* __tstate = wxPyBeginAllowThreads();
42562 (arg1)->SetText((wxString const &)*arg2);
42563 wxPyEndAllowThreads(__tstate);
42564 if (PyErr_Occurred()) SWIG_fail;
42565 }
42566 resultobj = SWIG_Py_Void();
42567 {
42568 if (temp2)
42569 delete arg2;
42570 }
42571 return resultobj;
42572 fail:
42573 {
42574 if (temp2)
42575 delete arg2;
42576 }
42577 return NULL;
42578 }
42579
42580
42581 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42582 PyObject *resultobj = 0;
42583 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42584 wxString result;
42585 void *argp1 = 0 ;
42586 int res1 = 0 ;
42587 PyObject *swig_obj[1] ;
42588
42589 if (!args) SWIG_fail;
42590 swig_obj[0] = args;
42591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42592 if (!SWIG_IsOK(res1)) {
42593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42594 }
42595 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42596 {
42597 PyThreadState* __tstate = wxPyBeginAllowThreads();
42598 result = ((wxMenuItem const *)arg1)->GetLabel();
42599 wxPyEndAllowThreads(__tstate);
42600 if (PyErr_Occurred()) SWIG_fail;
42601 }
42602 {
42603 #if wxUSE_UNICODE
42604 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42605 #else
42606 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42607 #endif
42608 }
42609 return resultobj;
42610 fail:
42611 return NULL;
42612 }
42613
42614
42615 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42616 PyObject *resultobj = 0;
42617 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42618 wxString *result = 0 ;
42619 void *argp1 = 0 ;
42620 int res1 = 0 ;
42621 PyObject *swig_obj[1] ;
42622
42623 if (!args) SWIG_fail;
42624 swig_obj[0] = args;
42625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42626 if (!SWIG_IsOK(res1)) {
42627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42628 }
42629 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42630 {
42631 PyThreadState* __tstate = wxPyBeginAllowThreads();
42632 {
42633 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42634 result = (wxString *) &_result_ref;
42635 }
42636 wxPyEndAllowThreads(__tstate);
42637 if (PyErr_Occurred()) SWIG_fail;
42638 }
42639 {
42640 #if wxUSE_UNICODE
42641 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42642 #else
42643 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42644 #endif
42645 }
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj = 0;
42654 wxString *arg1 = 0 ;
42655 wxString result;
42656 bool temp1 = false ;
42657 PyObject * obj0 = 0 ;
42658 char * kwnames[] = {
42659 (char *) "text", NULL
42660 };
42661
42662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42663 {
42664 arg1 = wxString_in_helper(obj0);
42665 if (arg1 == NULL) SWIG_fail;
42666 temp1 = true;
42667 }
42668 {
42669 PyThreadState* __tstate = wxPyBeginAllowThreads();
42670 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42671 wxPyEndAllowThreads(__tstate);
42672 if (PyErr_Occurred()) SWIG_fail;
42673 }
42674 {
42675 #if wxUSE_UNICODE
42676 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42677 #else
42678 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42679 #endif
42680 }
42681 {
42682 if (temp1)
42683 delete arg1;
42684 }
42685 return resultobj;
42686 fail:
42687 {
42688 if (temp1)
42689 delete arg1;
42690 }
42691 return NULL;
42692 }
42693
42694
42695 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42696 PyObject *resultobj = 0;
42697 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42698 wxItemKind result;
42699 void *argp1 = 0 ;
42700 int res1 = 0 ;
42701 PyObject *swig_obj[1] ;
42702
42703 if (!args) SWIG_fail;
42704 swig_obj[0] = args;
42705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42706 if (!SWIG_IsOK(res1)) {
42707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42708 }
42709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42710 {
42711 PyThreadState* __tstate = wxPyBeginAllowThreads();
42712 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42713 wxPyEndAllowThreads(__tstate);
42714 if (PyErr_Occurred()) SWIG_fail;
42715 }
42716 resultobj = SWIG_From_int(static_cast< int >(result));
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42724 PyObject *resultobj = 0;
42725 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42726 wxItemKind arg2 ;
42727 void *argp1 = 0 ;
42728 int res1 = 0 ;
42729 int val2 ;
42730 int ecode2 = 0 ;
42731 PyObject * obj0 = 0 ;
42732 PyObject * obj1 = 0 ;
42733 char * kwnames[] = {
42734 (char *) "self",(char *) "kind", NULL
42735 };
42736
42737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42739 if (!SWIG_IsOK(res1)) {
42740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42741 }
42742 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42743 ecode2 = SWIG_AsVal_int(obj1, &val2);
42744 if (!SWIG_IsOK(ecode2)) {
42745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42746 }
42747 arg2 = static_cast< wxItemKind >(val2);
42748 {
42749 PyThreadState* __tstate = wxPyBeginAllowThreads();
42750 (arg1)->SetKind(arg2);
42751 wxPyEndAllowThreads(__tstate);
42752 if (PyErr_Occurred()) SWIG_fail;
42753 }
42754 resultobj = SWIG_Py_Void();
42755 return resultobj;
42756 fail:
42757 return NULL;
42758 }
42759
42760
42761 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42762 PyObject *resultobj = 0;
42763 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42764 bool arg2 ;
42765 void *argp1 = 0 ;
42766 int res1 = 0 ;
42767 bool val2 ;
42768 int ecode2 = 0 ;
42769 PyObject * obj0 = 0 ;
42770 PyObject * obj1 = 0 ;
42771 char * kwnames[] = {
42772 (char *) "self",(char *) "checkable", NULL
42773 };
42774
42775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42777 if (!SWIG_IsOK(res1)) {
42778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42779 }
42780 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42781 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42782 if (!SWIG_IsOK(ecode2)) {
42783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42784 }
42785 arg2 = static_cast< bool >(val2);
42786 {
42787 PyThreadState* __tstate = wxPyBeginAllowThreads();
42788 (arg1)->SetCheckable(arg2);
42789 wxPyEndAllowThreads(__tstate);
42790 if (PyErr_Occurred()) SWIG_fail;
42791 }
42792 resultobj = SWIG_Py_Void();
42793 return resultobj;
42794 fail:
42795 return NULL;
42796 }
42797
42798
42799 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42800 PyObject *resultobj = 0;
42801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42802 bool result;
42803 void *argp1 = 0 ;
42804 int res1 = 0 ;
42805 PyObject *swig_obj[1] ;
42806
42807 if (!args) SWIG_fail;
42808 swig_obj[0] = args;
42809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42810 if (!SWIG_IsOK(res1)) {
42811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42812 }
42813 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42814 {
42815 PyThreadState* __tstate = wxPyBeginAllowThreads();
42816 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42817 wxPyEndAllowThreads(__tstate);
42818 if (PyErr_Occurred()) SWIG_fail;
42819 }
42820 {
42821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42822 }
42823 return resultobj;
42824 fail:
42825 return NULL;
42826 }
42827
42828
42829 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42830 PyObject *resultobj = 0;
42831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42832 bool result;
42833 void *argp1 = 0 ;
42834 int res1 = 0 ;
42835 PyObject *swig_obj[1] ;
42836
42837 if (!args) SWIG_fail;
42838 swig_obj[0] = args;
42839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42840 if (!SWIG_IsOK(res1)) {
42841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42842 }
42843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42847 wxPyEndAllowThreads(__tstate);
42848 if (PyErr_Occurred()) SWIG_fail;
42849 }
42850 {
42851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42852 }
42853 return resultobj;
42854 fail:
42855 return NULL;
42856 }
42857
42858
42859 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42860 PyObject *resultobj = 0;
42861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42862 wxMenu *arg2 = (wxMenu *) 0 ;
42863 void *argp1 = 0 ;
42864 int res1 = 0 ;
42865 void *argp2 = 0 ;
42866 int res2 = 0 ;
42867 PyObject * obj0 = 0 ;
42868 PyObject * obj1 = 0 ;
42869 char * kwnames[] = {
42870 (char *) "self",(char *) "menu", NULL
42871 };
42872
42873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42875 if (!SWIG_IsOK(res1)) {
42876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42877 }
42878 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42880 if (!SWIG_IsOK(res2)) {
42881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42882 }
42883 arg2 = reinterpret_cast< wxMenu * >(argp2);
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 (arg1)->SetSubMenu(arg2);
42887 wxPyEndAllowThreads(__tstate);
42888 if (PyErr_Occurred()) SWIG_fail;
42889 }
42890 resultobj = SWIG_Py_Void();
42891 return resultobj;
42892 fail:
42893 return NULL;
42894 }
42895
42896
42897 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42898 PyObject *resultobj = 0;
42899 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42900 wxMenu *result = 0 ;
42901 void *argp1 = 0 ;
42902 int res1 = 0 ;
42903 PyObject *swig_obj[1] ;
42904
42905 if (!args) SWIG_fail;
42906 swig_obj[0] = args;
42907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42908 if (!SWIG_IsOK(res1)) {
42909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42910 }
42911 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42912 {
42913 PyThreadState* __tstate = wxPyBeginAllowThreads();
42914 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42915 wxPyEndAllowThreads(__tstate);
42916 if (PyErr_Occurred()) SWIG_fail;
42917 }
42918 {
42919 resultobj = wxPyMake_wxObject(result, 0);
42920 }
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42930 bool arg2 = (bool) true ;
42931 void *argp1 = 0 ;
42932 int res1 = 0 ;
42933 bool val2 ;
42934 int ecode2 = 0 ;
42935 PyObject * obj0 = 0 ;
42936 PyObject * obj1 = 0 ;
42937 char * kwnames[] = {
42938 (char *) "self",(char *) "enable", NULL
42939 };
42940
42941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42943 if (!SWIG_IsOK(res1)) {
42944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42945 }
42946 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42947 if (obj1) {
42948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42949 if (!SWIG_IsOK(ecode2)) {
42950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42951 }
42952 arg2 = static_cast< bool >(val2);
42953 }
42954 {
42955 PyThreadState* __tstate = wxPyBeginAllowThreads();
42956 (arg1)->Enable(arg2);
42957 wxPyEndAllowThreads(__tstate);
42958 if (PyErr_Occurred()) SWIG_fail;
42959 }
42960 resultobj = SWIG_Py_Void();
42961 return resultobj;
42962 fail:
42963 return NULL;
42964 }
42965
42966
42967 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42968 PyObject *resultobj = 0;
42969 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42970 bool result;
42971 void *argp1 = 0 ;
42972 int res1 = 0 ;
42973 PyObject *swig_obj[1] ;
42974
42975 if (!args) SWIG_fail;
42976 swig_obj[0] = args;
42977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42978 if (!SWIG_IsOK(res1)) {
42979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42980 }
42981 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42982 {
42983 PyThreadState* __tstate = wxPyBeginAllowThreads();
42984 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42985 wxPyEndAllowThreads(__tstate);
42986 if (PyErr_Occurred()) SWIG_fail;
42987 }
42988 {
42989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42990 }
42991 return resultobj;
42992 fail:
42993 return NULL;
42994 }
42995
42996
42997 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42998 PyObject *resultobj = 0;
42999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43000 bool arg2 = (bool) true ;
43001 void *argp1 = 0 ;
43002 int res1 = 0 ;
43003 bool val2 ;
43004 int ecode2 = 0 ;
43005 PyObject * obj0 = 0 ;
43006 PyObject * obj1 = 0 ;
43007 char * kwnames[] = {
43008 (char *) "self",(char *) "check", NULL
43009 };
43010
43011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43013 if (!SWIG_IsOK(res1)) {
43014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43015 }
43016 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43017 if (obj1) {
43018 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43019 if (!SWIG_IsOK(ecode2)) {
43020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43021 }
43022 arg2 = static_cast< bool >(val2);
43023 }
43024 {
43025 PyThreadState* __tstate = wxPyBeginAllowThreads();
43026 (arg1)->Check(arg2);
43027 wxPyEndAllowThreads(__tstate);
43028 if (PyErr_Occurred()) SWIG_fail;
43029 }
43030 resultobj = SWIG_Py_Void();
43031 return resultobj;
43032 fail:
43033 return NULL;
43034 }
43035
43036
43037 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43038 PyObject *resultobj = 0;
43039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43040 bool result;
43041 void *argp1 = 0 ;
43042 int res1 = 0 ;
43043 PyObject *swig_obj[1] ;
43044
43045 if (!args) SWIG_fail;
43046 swig_obj[0] = args;
43047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43048 if (!SWIG_IsOK(res1)) {
43049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43050 }
43051 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43052 {
43053 PyThreadState* __tstate = wxPyBeginAllowThreads();
43054 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 {
43059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43060 }
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43068 PyObject *resultobj = 0;
43069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43070 void *argp1 = 0 ;
43071 int res1 = 0 ;
43072 PyObject *swig_obj[1] ;
43073
43074 if (!args) SWIG_fail;
43075 swig_obj[0] = args;
43076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43077 if (!SWIG_IsOK(res1)) {
43078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43079 }
43080 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43081 {
43082 PyThreadState* __tstate = wxPyBeginAllowThreads();
43083 (arg1)->Toggle();
43084 wxPyEndAllowThreads(__tstate);
43085 if (PyErr_Occurred()) SWIG_fail;
43086 }
43087 resultobj = SWIG_Py_Void();
43088 return resultobj;
43089 fail:
43090 return NULL;
43091 }
43092
43093
43094 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43095 PyObject *resultobj = 0;
43096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43097 wxString *arg2 = 0 ;
43098 void *argp1 = 0 ;
43099 int res1 = 0 ;
43100 bool temp2 = false ;
43101 PyObject * obj0 = 0 ;
43102 PyObject * obj1 = 0 ;
43103 char * kwnames[] = {
43104 (char *) "self",(char *) "str", NULL
43105 };
43106
43107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43109 if (!SWIG_IsOK(res1)) {
43110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43111 }
43112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43113 {
43114 arg2 = wxString_in_helper(obj1);
43115 if (arg2 == NULL) SWIG_fail;
43116 temp2 = true;
43117 }
43118 {
43119 PyThreadState* __tstate = wxPyBeginAllowThreads();
43120 (arg1)->SetHelp((wxString const &)*arg2);
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 resultobj = SWIG_Py_Void();
43125 {
43126 if (temp2)
43127 delete arg2;
43128 }
43129 return resultobj;
43130 fail:
43131 {
43132 if (temp2)
43133 delete arg2;
43134 }
43135 return NULL;
43136 }
43137
43138
43139 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43140 PyObject *resultobj = 0;
43141 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43142 wxString *result = 0 ;
43143 void *argp1 = 0 ;
43144 int res1 = 0 ;
43145 PyObject *swig_obj[1] ;
43146
43147 if (!args) SWIG_fail;
43148 swig_obj[0] = args;
43149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43150 if (!SWIG_IsOK(res1)) {
43151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43152 }
43153 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43154 {
43155 PyThreadState* __tstate = wxPyBeginAllowThreads();
43156 {
43157 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43158 result = (wxString *) &_result_ref;
43159 }
43160 wxPyEndAllowThreads(__tstate);
43161 if (PyErr_Occurred()) SWIG_fail;
43162 }
43163 {
43164 #if wxUSE_UNICODE
43165 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43166 #else
43167 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43168 #endif
43169 }
43170 return resultobj;
43171 fail:
43172 return NULL;
43173 }
43174
43175
43176 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43177 PyObject *resultobj = 0;
43178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43179 wxAcceleratorEntry *result = 0 ;
43180 void *argp1 = 0 ;
43181 int res1 = 0 ;
43182 PyObject *swig_obj[1] ;
43183
43184 if (!args) SWIG_fail;
43185 swig_obj[0] = args;
43186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43198 return resultobj;
43199 fail:
43200 return NULL;
43201 }
43202
43203
43204 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43205 PyObject *resultobj = 0;
43206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43207 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43208 void *argp1 = 0 ;
43209 int res1 = 0 ;
43210 void *argp2 = 0 ;
43211 int res2 = 0 ;
43212 PyObject * obj0 = 0 ;
43213 PyObject * obj1 = 0 ;
43214 char * kwnames[] = {
43215 (char *) "self",(char *) "accel", NULL
43216 };
43217
43218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43220 if (!SWIG_IsOK(res1)) {
43221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43222 }
43223 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43225 if (!SWIG_IsOK(res2)) {
43226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43227 }
43228 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43229 {
43230 PyThreadState* __tstate = wxPyBeginAllowThreads();
43231 (arg1)->SetAccel(arg2);
43232 wxPyEndAllowThreads(__tstate);
43233 if (PyErr_Occurred()) SWIG_fail;
43234 }
43235 resultobj = SWIG_Py_Void();
43236 return resultobj;
43237 fail:
43238 return NULL;
43239 }
43240
43241
43242 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43243 PyObject *resultobj = 0;
43244 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43245 wxBitmap *arg2 = 0 ;
43246 void *argp1 = 0 ;
43247 int res1 = 0 ;
43248 void *argp2 = 0 ;
43249 int res2 = 0 ;
43250 PyObject * obj0 = 0 ;
43251 PyObject * obj1 = 0 ;
43252 char * kwnames[] = {
43253 (char *) "self",(char *) "bitmap", NULL
43254 };
43255
43256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43258 if (!SWIG_IsOK(res1)) {
43259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43260 }
43261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43263 if (!SWIG_IsOK(res2)) {
43264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43265 }
43266 if (!argp2) {
43267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43268 }
43269 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43273 wxPyEndAllowThreads(__tstate);
43274 if (PyErr_Occurred()) SWIG_fail;
43275 }
43276 resultobj = SWIG_Py_Void();
43277 return resultobj;
43278 fail:
43279 return NULL;
43280 }
43281
43282
43283 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43284 PyObject *resultobj = 0;
43285 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43286 wxBitmap *result = 0 ;
43287 void *argp1 = 0 ;
43288 int res1 = 0 ;
43289 PyObject *swig_obj[1] ;
43290
43291 if (!args) SWIG_fail;
43292 swig_obj[0] = args;
43293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43294 if (!SWIG_IsOK(res1)) {
43295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43296 }
43297 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 {
43301 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43302 result = (wxBitmap *) &_result_ref;
43303 }
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 wxBitmap* resultptr = new wxBitmap(*result);
43309 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43310 }
43311 return resultobj;
43312 fail:
43313 return NULL;
43314 }
43315
43316
43317 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43318 PyObject *resultobj = 0;
43319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43320 wxFont *arg2 = 0 ;
43321 void *argp1 = 0 ;
43322 int res1 = 0 ;
43323 void *argp2 = 0 ;
43324 int res2 = 0 ;
43325 PyObject * obj0 = 0 ;
43326 PyObject * obj1 = 0 ;
43327 char * kwnames[] = {
43328 (char *) "self",(char *) "font", NULL
43329 };
43330
43331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43333 if (!SWIG_IsOK(res1)) {
43334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43335 }
43336 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43337 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43338 if (!SWIG_IsOK(res2)) {
43339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43340 }
43341 if (!argp2) {
43342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43343 }
43344 arg2 = reinterpret_cast< wxFont * >(argp2);
43345 {
43346 PyThreadState* __tstate = wxPyBeginAllowThreads();
43347 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 resultobj = SWIG_Py_Void();
43352 return resultobj;
43353 fail:
43354 return NULL;
43355 }
43356
43357
43358 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43359 PyObject *resultobj = 0;
43360 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43361 wxFont result;
43362 void *argp1 = 0 ;
43363 int res1 = 0 ;
43364 PyObject *swig_obj[1] ;
43365
43366 if (!args) SWIG_fail;
43367 swig_obj[0] = args;
43368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43369 if (!SWIG_IsOK(res1)) {
43370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43371 }
43372 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43373 {
43374 PyThreadState* __tstate = wxPyBeginAllowThreads();
43375 result = wxMenuItem_GetFont(arg1);
43376 wxPyEndAllowThreads(__tstate);
43377 if (PyErr_Occurred()) SWIG_fail;
43378 }
43379 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43380 return resultobj;
43381 fail:
43382 return NULL;
43383 }
43384
43385
43386 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43387 PyObject *resultobj = 0;
43388 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43389 wxColour *arg2 = 0 ;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 wxColour temp2 ;
43393 PyObject * obj0 = 0 ;
43394 PyObject * obj1 = 0 ;
43395 char * kwnames[] = {
43396 (char *) "self",(char *) "colText", NULL
43397 };
43398
43399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43401 if (!SWIG_IsOK(res1)) {
43402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43403 }
43404 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43405 {
43406 arg2 = &temp2;
43407 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43408 }
43409 {
43410 PyThreadState* __tstate = wxPyBeginAllowThreads();
43411 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43412 wxPyEndAllowThreads(__tstate);
43413 if (PyErr_Occurred()) SWIG_fail;
43414 }
43415 resultobj = SWIG_Py_Void();
43416 return resultobj;
43417 fail:
43418 return NULL;
43419 }
43420
43421
43422 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43423 PyObject *resultobj = 0;
43424 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43425 wxColour result;
43426 void *argp1 = 0 ;
43427 int res1 = 0 ;
43428 PyObject *swig_obj[1] ;
43429
43430 if (!args) SWIG_fail;
43431 swig_obj[0] = args;
43432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43433 if (!SWIG_IsOK(res1)) {
43434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43435 }
43436 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43437 {
43438 PyThreadState* __tstate = wxPyBeginAllowThreads();
43439 result = wxMenuItem_GetTextColour(arg1);
43440 wxPyEndAllowThreads(__tstate);
43441 if (PyErr_Occurred()) SWIG_fail;
43442 }
43443 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43444 return resultobj;
43445 fail:
43446 return NULL;
43447 }
43448
43449
43450 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43451 PyObject *resultobj = 0;
43452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43453 wxColour *arg2 = 0 ;
43454 void *argp1 = 0 ;
43455 int res1 = 0 ;
43456 wxColour temp2 ;
43457 PyObject * obj0 = 0 ;
43458 PyObject * obj1 = 0 ;
43459 char * kwnames[] = {
43460 (char *) "self",(char *) "colBack", NULL
43461 };
43462
43463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43465 if (!SWIG_IsOK(res1)) {
43466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43467 }
43468 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43469 {
43470 arg2 = &temp2;
43471 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43472 }
43473 {
43474 PyThreadState* __tstate = wxPyBeginAllowThreads();
43475 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43476 wxPyEndAllowThreads(__tstate);
43477 if (PyErr_Occurred()) SWIG_fail;
43478 }
43479 resultobj = SWIG_Py_Void();
43480 return resultobj;
43481 fail:
43482 return NULL;
43483 }
43484
43485
43486 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43487 PyObject *resultobj = 0;
43488 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43489 wxColour result;
43490 void *argp1 = 0 ;
43491 int res1 = 0 ;
43492 PyObject *swig_obj[1] ;
43493
43494 if (!args) SWIG_fail;
43495 swig_obj[0] = args;
43496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43497 if (!SWIG_IsOK(res1)) {
43498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43499 }
43500 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43501 {
43502 PyThreadState* __tstate = wxPyBeginAllowThreads();
43503 result = wxMenuItem_GetBackgroundColour(arg1);
43504 wxPyEndAllowThreads(__tstate);
43505 if (PyErr_Occurred()) SWIG_fail;
43506 }
43507 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43508 return resultobj;
43509 fail:
43510 return NULL;
43511 }
43512
43513
43514 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43515 PyObject *resultobj = 0;
43516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43517 wxBitmap *arg2 = 0 ;
43518 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43519 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43520 void *argp1 = 0 ;
43521 int res1 = 0 ;
43522 void *argp2 = 0 ;
43523 int res2 = 0 ;
43524 void *argp3 = 0 ;
43525 int res3 = 0 ;
43526 PyObject * obj0 = 0 ;
43527 PyObject * obj1 = 0 ;
43528 PyObject * obj2 = 0 ;
43529 char * kwnames[] = {
43530 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43531 };
43532
43533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43535 if (!SWIG_IsOK(res1)) {
43536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43537 }
43538 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43540 if (!SWIG_IsOK(res2)) {
43541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43542 }
43543 if (!argp2) {
43544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43545 }
43546 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43547 if (obj2) {
43548 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43549 if (!SWIG_IsOK(res3)) {
43550 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43551 }
43552 if (!argp3) {
43553 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43554 }
43555 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43556 }
43557 {
43558 PyThreadState* __tstate = wxPyBeginAllowThreads();
43559 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43560 wxPyEndAllowThreads(__tstate);
43561 if (PyErr_Occurred()) SWIG_fail;
43562 }
43563 resultobj = SWIG_Py_Void();
43564 return resultobj;
43565 fail:
43566 return NULL;
43567 }
43568
43569
43570 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43571 PyObject *resultobj = 0;
43572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43573 wxBitmap *arg2 = 0 ;
43574 void *argp1 = 0 ;
43575 int res1 = 0 ;
43576 void *argp2 = 0 ;
43577 int res2 = 0 ;
43578 PyObject * obj0 = 0 ;
43579 PyObject * obj1 = 0 ;
43580 char * kwnames[] = {
43581 (char *) "self",(char *) "bmpDisabled", NULL
43582 };
43583
43584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43586 if (!SWIG_IsOK(res1)) {
43587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43588 }
43589 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43590 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43591 if (!SWIG_IsOK(res2)) {
43592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43593 }
43594 if (!argp2) {
43595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43596 }
43597 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 resultobj = SWIG_Py_Void();
43605 return resultobj;
43606 fail:
43607 return NULL;
43608 }
43609
43610
43611 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43612 PyObject *resultobj = 0;
43613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43614 wxBitmap *result = 0 ;
43615 void *argp1 = 0 ;
43616 int res1 = 0 ;
43617 PyObject *swig_obj[1] ;
43618
43619 if (!args) SWIG_fail;
43620 swig_obj[0] = args;
43621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43622 if (!SWIG_IsOK(res1)) {
43623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43624 }
43625 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43626 {
43627 PyThreadState* __tstate = wxPyBeginAllowThreads();
43628 {
43629 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43630 result = (wxBitmap *) &_result_ref;
43631 }
43632 wxPyEndAllowThreads(__tstate);
43633 if (PyErr_Occurred()) SWIG_fail;
43634 }
43635 {
43636 wxBitmap* resultptr = new wxBitmap(*result);
43637 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43638 }
43639 return resultobj;
43640 fail:
43641 return NULL;
43642 }
43643
43644
43645 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43646 PyObject *resultobj = 0;
43647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43648 int arg2 ;
43649 void *argp1 = 0 ;
43650 int res1 = 0 ;
43651 int val2 ;
43652 int ecode2 = 0 ;
43653 PyObject * obj0 = 0 ;
43654 PyObject * obj1 = 0 ;
43655 char * kwnames[] = {
43656 (char *) "self",(char *) "nWidth", NULL
43657 };
43658
43659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43661 if (!SWIG_IsOK(res1)) {
43662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43663 }
43664 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43665 ecode2 = SWIG_AsVal_int(obj1, &val2);
43666 if (!SWIG_IsOK(ecode2)) {
43667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43668 }
43669 arg2 = static_cast< int >(val2);
43670 {
43671 PyThreadState* __tstate = wxPyBeginAllowThreads();
43672 wxMenuItem_SetMarginWidth(arg1,arg2);
43673 wxPyEndAllowThreads(__tstate);
43674 if (PyErr_Occurred()) SWIG_fail;
43675 }
43676 resultobj = SWIG_Py_Void();
43677 return resultobj;
43678 fail:
43679 return NULL;
43680 }
43681
43682
43683 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43684 PyObject *resultobj = 0;
43685 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43686 int result;
43687 void *argp1 = 0 ;
43688 int res1 = 0 ;
43689 PyObject *swig_obj[1] ;
43690
43691 if (!args) SWIG_fail;
43692 swig_obj[0] = args;
43693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43694 if (!SWIG_IsOK(res1)) {
43695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43696 }
43697 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43698 {
43699 PyThreadState* __tstate = wxPyBeginAllowThreads();
43700 result = (int)wxMenuItem_GetMarginWidth(arg1);
43701 wxPyEndAllowThreads(__tstate);
43702 if (PyErr_Occurred()) SWIG_fail;
43703 }
43704 resultobj = SWIG_From_int(static_cast< int >(result));
43705 return resultobj;
43706 fail:
43707 return NULL;
43708 }
43709
43710
43711 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43712 PyObject *resultobj = 0;
43713 int result;
43714
43715 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43716 {
43717 PyThreadState* __tstate = wxPyBeginAllowThreads();
43718 result = (int)wxMenuItem_GetDefaultMarginWidth();
43719 wxPyEndAllowThreads(__tstate);
43720 if (PyErr_Occurred()) SWIG_fail;
43721 }
43722 resultobj = SWIG_From_int(static_cast< int >(result));
43723 return resultobj;
43724 fail:
43725 return NULL;
43726 }
43727
43728
43729 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43730 PyObject *resultobj = 0;
43731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43732 bool result;
43733 void *argp1 = 0 ;
43734 int res1 = 0 ;
43735 PyObject *swig_obj[1] ;
43736
43737 if (!args) SWIG_fail;
43738 swig_obj[0] = args;
43739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43740 if (!SWIG_IsOK(res1)) {
43741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43742 }
43743 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43747 wxPyEndAllowThreads(__tstate);
43748 if (PyErr_Occurred()) SWIG_fail;
43749 }
43750 {
43751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43752 }
43753 return resultobj;
43754 fail:
43755 return NULL;
43756 }
43757
43758
43759 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43760 PyObject *resultobj = 0;
43761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43762 bool arg2 = (bool) true ;
43763 void *argp1 = 0 ;
43764 int res1 = 0 ;
43765 bool val2 ;
43766 int ecode2 = 0 ;
43767 PyObject * obj0 = 0 ;
43768 PyObject * obj1 = 0 ;
43769 char * kwnames[] = {
43770 (char *) "self",(char *) "ownerDrawn", NULL
43771 };
43772
43773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43775 if (!SWIG_IsOK(res1)) {
43776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43777 }
43778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43779 if (obj1) {
43780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43781 if (!SWIG_IsOK(ecode2)) {
43782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43783 }
43784 arg2 = static_cast< bool >(val2);
43785 }
43786 {
43787 PyThreadState* __tstate = wxPyBeginAllowThreads();
43788 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43789 wxPyEndAllowThreads(__tstate);
43790 if (PyErr_Occurred()) SWIG_fail;
43791 }
43792 resultobj = SWIG_Py_Void();
43793 return resultobj;
43794 fail:
43795 return NULL;
43796 }
43797
43798
43799 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43800 PyObject *resultobj = 0;
43801 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43802 void *argp1 = 0 ;
43803 int res1 = 0 ;
43804 PyObject *swig_obj[1] ;
43805
43806 if (!args) SWIG_fail;
43807 swig_obj[0] = args;
43808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43813 {
43814 PyThreadState* __tstate = wxPyBeginAllowThreads();
43815 wxMenuItem_ResetOwnerDrawn(arg1);
43816 wxPyEndAllowThreads(__tstate);
43817 if (PyErr_Occurred()) SWIG_fail;
43818 }
43819 resultobj = SWIG_Py_Void();
43820 return resultobj;
43821 fail:
43822 return NULL;
43823 }
43824
43825
43826 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43827 PyObject *obj;
43828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43829 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43830 return SWIG_Py_Void();
43831 }
43832
43833 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43834 return SWIG_Python_InitShadowInstance(args);
43835 }
43836
43837 SWIGINTERN int ControlNameStr_set(PyObject *) {
43838 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43839 return 1;
43840 }
43841
43842
43843 SWIGINTERN PyObject *ControlNameStr_get(void) {
43844 PyObject *pyobj = 0;
43845
43846 {
43847 #if wxUSE_UNICODE
43848 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43849 #else
43850 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43851 #endif
43852 }
43853 return pyobj;
43854 }
43855
43856
43857 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43858 PyObject *resultobj = 0;
43859 wxWindow *arg1 = (wxWindow *) 0 ;
43860 int arg2 = (int) -1 ;
43861 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43862 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43863 wxSize const &arg4_defvalue = wxDefaultSize ;
43864 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43865 long arg5 = (long) 0 ;
43866 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43867 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43868 wxString const &arg7_defvalue = wxPyControlNameStr ;
43869 wxString *arg7 = (wxString *) &arg7_defvalue ;
43870 wxControl *result = 0 ;
43871 void *argp1 = 0 ;
43872 int res1 = 0 ;
43873 int val2 ;
43874 int ecode2 = 0 ;
43875 wxPoint temp3 ;
43876 wxSize temp4 ;
43877 long val5 ;
43878 int ecode5 = 0 ;
43879 void *argp6 = 0 ;
43880 int res6 = 0 ;
43881 bool temp7 = false ;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884 PyObject * obj2 = 0 ;
43885 PyObject * obj3 = 0 ;
43886 PyObject * obj4 = 0 ;
43887 PyObject * obj5 = 0 ;
43888 PyObject * obj6 = 0 ;
43889 char * kwnames[] = {
43890 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43891 };
43892
43893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43895 if (!SWIG_IsOK(res1)) {
43896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43897 }
43898 arg1 = reinterpret_cast< wxWindow * >(argp1);
43899 if (obj1) {
43900 ecode2 = SWIG_AsVal_int(obj1, &val2);
43901 if (!SWIG_IsOK(ecode2)) {
43902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43903 }
43904 arg2 = static_cast< int >(val2);
43905 }
43906 if (obj2) {
43907 {
43908 arg3 = &temp3;
43909 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43910 }
43911 }
43912 if (obj3) {
43913 {
43914 arg4 = &temp4;
43915 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43916 }
43917 }
43918 if (obj4) {
43919 ecode5 = SWIG_AsVal_long(obj4, &val5);
43920 if (!SWIG_IsOK(ecode5)) {
43921 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43922 }
43923 arg5 = static_cast< long >(val5);
43924 }
43925 if (obj5) {
43926 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43927 if (!SWIG_IsOK(res6)) {
43928 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43929 }
43930 if (!argp6) {
43931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43932 }
43933 arg6 = reinterpret_cast< wxValidator * >(argp6);
43934 }
43935 if (obj6) {
43936 {
43937 arg7 = wxString_in_helper(obj6);
43938 if (arg7 == NULL) SWIG_fail;
43939 temp7 = true;
43940 }
43941 }
43942 {
43943 if (!wxPyCheckForApp()) SWIG_fail;
43944 PyThreadState* __tstate = wxPyBeginAllowThreads();
43945 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43946 wxPyEndAllowThreads(__tstate);
43947 if (PyErr_Occurred()) SWIG_fail;
43948 }
43949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43950 {
43951 if (temp7)
43952 delete arg7;
43953 }
43954 return resultobj;
43955 fail:
43956 {
43957 if (temp7)
43958 delete arg7;
43959 }
43960 return NULL;
43961 }
43962
43963
43964 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43965 PyObject *resultobj = 0;
43966 wxControl *result = 0 ;
43967
43968 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43969 {
43970 if (!wxPyCheckForApp()) SWIG_fail;
43971 PyThreadState* __tstate = wxPyBeginAllowThreads();
43972 result = (wxControl *)new wxControl();
43973 wxPyEndAllowThreads(__tstate);
43974 if (PyErr_Occurred()) SWIG_fail;
43975 }
43976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43977 return resultobj;
43978 fail:
43979 return NULL;
43980 }
43981
43982
43983 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43984 PyObject *resultobj = 0;
43985 wxControl *arg1 = (wxControl *) 0 ;
43986 wxWindow *arg2 = (wxWindow *) 0 ;
43987 int arg3 = (int) -1 ;
43988 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43989 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43990 wxSize const &arg5_defvalue = wxDefaultSize ;
43991 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43992 long arg6 = (long) 0 ;
43993 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43994 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43995 wxString const &arg8_defvalue = wxPyControlNameStr ;
43996 wxString *arg8 = (wxString *) &arg8_defvalue ;
43997 bool result;
43998 void *argp1 = 0 ;
43999 int res1 = 0 ;
44000 void *argp2 = 0 ;
44001 int res2 = 0 ;
44002 int val3 ;
44003 int ecode3 = 0 ;
44004 wxPoint temp4 ;
44005 wxSize temp5 ;
44006 long val6 ;
44007 int ecode6 = 0 ;
44008 void *argp7 = 0 ;
44009 int res7 = 0 ;
44010 bool temp8 = false ;
44011 PyObject * obj0 = 0 ;
44012 PyObject * obj1 = 0 ;
44013 PyObject * obj2 = 0 ;
44014 PyObject * obj3 = 0 ;
44015 PyObject * obj4 = 0 ;
44016 PyObject * obj5 = 0 ;
44017 PyObject * obj6 = 0 ;
44018 PyObject * obj7 = 0 ;
44019 char * kwnames[] = {
44020 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44021 };
44022
44023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44025 if (!SWIG_IsOK(res1)) {
44026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44027 }
44028 arg1 = reinterpret_cast< wxControl * >(argp1);
44029 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44030 if (!SWIG_IsOK(res2)) {
44031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44032 }
44033 arg2 = reinterpret_cast< wxWindow * >(argp2);
44034 if (obj2) {
44035 ecode3 = SWIG_AsVal_int(obj2, &val3);
44036 if (!SWIG_IsOK(ecode3)) {
44037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44038 }
44039 arg3 = static_cast< int >(val3);
44040 }
44041 if (obj3) {
44042 {
44043 arg4 = &temp4;
44044 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44045 }
44046 }
44047 if (obj4) {
44048 {
44049 arg5 = &temp5;
44050 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44051 }
44052 }
44053 if (obj5) {
44054 ecode6 = SWIG_AsVal_long(obj5, &val6);
44055 if (!SWIG_IsOK(ecode6)) {
44056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44057 }
44058 arg6 = static_cast< long >(val6);
44059 }
44060 if (obj6) {
44061 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44062 if (!SWIG_IsOK(res7)) {
44063 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44064 }
44065 if (!argp7) {
44066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44067 }
44068 arg7 = reinterpret_cast< wxValidator * >(argp7);
44069 }
44070 if (obj7) {
44071 {
44072 arg8 = wxString_in_helper(obj7);
44073 if (arg8 == NULL) SWIG_fail;
44074 temp8 = true;
44075 }
44076 }
44077 {
44078 PyThreadState* __tstate = wxPyBeginAllowThreads();
44079 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44080 wxPyEndAllowThreads(__tstate);
44081 if (PyErr_Occurred()) SWIG_fail;
44082 }
44083 {
44084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44085 }
44086 {
44087 if (temp8)
44088 delete arg8;
44089 }
44090 return resultobj;
44091 fail:
44092 {
44093 if (temp8)
44094 delete arg8;
44095 }
44096 return NULL;
44097 }
44098
44099
44100 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44101 PyObject *resultobj = 0;
44102 wxControl *arg1 = (wxControl *) 0 ;
44103 int result;
44104 void *argp1 = 0 ;
44105 int res1 = 0 ;
44106 PyObject *swig_obj[1] ;
44107
44108 if (!args) SWIG_fail;
44109 swig_obj[0] = args;
44110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44111 if (!SWIG_IsOK(res1)) {
44112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44113 }
44114 arg1 = reinterpret_cast< wxControl * >(argp1);
44115 {
44116 PyThreadState* __tstate = wxPyBeginAllowThreads();
44117 result = (int)((wxControl const *)arg1)->GetAlignment();
44118 wxPyEndAllowThreads(__tstate);
44119 if (PyErr_Occurred()) SWIG_fail;
44120 }
44121 resultobj = SWIG_From_int(static_cast< int >(result));
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44129 PyObject *resultobj = 0;
44130 wxControl *arg1 = (wxControl *) 0 ;
44131 wxString result;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 PyObject *swig_obj[1] ;
44135
44136 if (!args) SWIG_fail;
44137 swig_obj[0] = args;
44138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44139 if (!SWIG_IsOK(res1)) {
44140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44141 }
44142 arg1 = reinterpret_cast< wxControl * >(argp1);
44143 {
44144 PyThreadState* __tstate = wxPyBeginAllowThreads();
44145 result = ((wxControl const *)arg1)->GetLabelText();
44146 wxPyEndAllowThreads(__tstate);
44147 if (PyErr_Occurred()) SWIG_fail;
44148 }
44149 {
44150 #if wxUSE_UNICODE
44151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44152 #else
44153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44154 #endif
44155 }
44156 return resultobj;
44157 fail:
44158 return NULL;
44159 }
44160
44161
44162 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44163 PyObject *resultobj = 0;
44164 wxControl *arg1 = (wxControl *) 0 ;
44165 wxCommandEvent *arg2 = 0 ;
44166 void *argp1 = 0 ;
44167 int res1 = 0 ;
44168 void *argp2 = 0 ;
44169 int res2 = 0 ;
44170 PyObject * obj0 = 0 ;
44171 PyObject * obj1 = 0 ;
44172 char * kwnames[] = {
44173 (char *) "self",(char *) "event", NULL
44174 };
44175
44176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44178 if (!SWIG_IsOK(res1)) {
44179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44180 }
44181 arg1 = reinterpret_cast< wxControl * >(argp1);
44182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44183 if (!SWIG_IsOK(res2)) {
44184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44185 }
44186 if (!argp2) {
44187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44188 }
44189 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44190 {
44191 PyThreadState* __tstate = wxPyBeginAllowThreads();
44192 (arg1)->Command(*arg2);
44193 wxPyEndAllowThreads(__tstate);
44194 if (PyErr_Occurred()) SWIG_fail;
44195 }
44196 resultobj = SWIG_Py_Void();
44197 return resultobj;
44198 fail:
44199 return NULL;
44200 }
44201
44202
44203 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44204 PyObject *resultobj = 0;
44205 wxControl *arg1 = (wxControl *) 0 ;
44206 wxString result;
44207 void *argp1 = 0 ;
44208 int res1 = 0 ;
44209 PyObject *swig_obj[1] ;
44210
44211 if (!args) SWIG_fail;
44212 swig_obj[0] = args;
44213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44214 if (!SWIG_IsOK(res1)) {
44215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44216 }
44217 arg1 = reinterpret_cast< wxControl * >(argp1);
44218 {
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 result = (arg1)->GetLabel();
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 {
44225 #if wxUSE_UNICODE
44226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44227 #else
44228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44229 #endif
44230 }
44231 return resultobj;
44232 fail:
44233 return NULL;
44234 }
44235
44236
44237 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44238 PyObject *resultobj = 0;
44239 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44240 SwigValueWrapper<wxVisualAttributes > result;
44241 int val1 ;
44242 int ecode1 = 0 ;
44243 PyObject * obj0 = 0 ;
44244 char * kwnames[] = {
44245 (char *) "variant", NULL
44246 };
44247
44248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44249 if (obj0) {
44250 ecode1 = SWIG_AsVal_int(obj0, &val1);
44251 if (!SWIG_IsOK(ecode1)) {
44252 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44253 }
44254 arg1 = static_cast< wxWindowVariant >(val1);
44255 }
44256 {
44257 if (!wxPyCheckForApp()) SWIG_fail;
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 result = wxControl::GetClassDefaultAttributes(arg1);
44260 wxPyEndAllowThreads(__tstate);
44261 if (PyErr_Occurred()) SWIG_fail;
44262 }
44263 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44264 return resultobj;
44265 fail:
44266 return NULL;
44267 }
44268
44269
44270 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44271 PyObject *obj;
44272 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44273 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44274 return SWIG_Py_Void();
44275 }
44276
44277 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44278 return SWIG_Python_InitShadowInstance(args);
44279 }
44280
44281 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44282 PyObject *resultobj = 0;
44283 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44284 wxString *arg2 = 0 ;
44285 PyObject *arg3 = (PyObject *) NULL ;
44286 int result;
44287 void *argp1 = 0 ;
44288 int res1 = 0 ;
44289 bool temp2 = false ;
44290 PyObject * obj0 = 0 ;
44291 PyObject * obj1 = 0 ;
44292 PyObject * obj2 = 0 ;
44293 char * kwnames[] = {
44294 (char *) "self",(char *) "item",(char *) "clientData", NULL
44295 };
44296
44297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44299 if (!SWIG_IsOK(res1)) {
44300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44301 }
44302 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44303 {
44304 arg2 = wxString_in_helper(obj1);
44305 if (arg2 == NULL) SWIG_fail;
44306 temp2 = true;
44307 }
44308 if (obj2) {
44309 arg3 = obj2;
44310 }
44311 {
44312 PyThreadState* __tstate = wxPyBeginAllowThreads();
44313 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44314 wxPyEndAllowThreads(__tstate);
44315 if (PyErr_Occurred()) SWIG_fail;
44316 }
44317 resultobj = SWIG_From_int(static_cast< int >(result));
44318 {
44319 if (temp2)
44320 delete arg2;
44321 }
44322 return resultobj;
44323 fail:
44324 {
44325 if (temp2)
44326 delete arg2;
44327 }
44328 return NULL;
44329 }
44330
44331
44332 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44333 PyObject *resultobj = 0;
44334 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44335 wxArrayString *arg2 = 0 ;
44336 void *argp1 = 0 ;
44337 int res1 = 0 ;
44338 bool temp2 = false ;
44339 PyObject * obj0 = 0 ;
44340 PyObject * obj1 = 0 ;
44341 char * kwnames[] = {
44342 (char *) "self",(char *) "strings", NULL
44343 };
44344
44345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44349 }
44350 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44351 {
44352 if (! PySequence_Check(obj1)) {
44353 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44354 SWIG_fail;
44355 }
44356 arg2 = new wxArrayString;
44357 temp2 = true;
44358 int i, len=PySequence_Length(obj1);
44359 for (i=0; i<len; i++) {
44360 PyObject* item = PySequence_GetItem(obj1, i);
44361 wxString* s = wxString_in_helper(item);
44362 if (PyErr_Occurred()) SWIG_fail;
44363 arg2->Add(*s);
44364 delete s;
44365 Py_DECREF(item);
44366 }
44367 }
44368 {
44369 PyThreadState* __tstate = wxPyBeginAllowThreads();
44370 (arg1)->Append((wxArrayString const &)*arg2);
44371 wxPyEndAllowThreads(__tstate);
44372 if (PyErr_Occurred()) SWIG_fail;
44373 }
44374 resultobj = SWIG_Py_Void();
44375 {
44376 if (temp2) delete arg2;
44377 }
44378 return resultobj;
44379 fail:
44380 {
44381 if (temp2) delete arg2;
44382 }
44383 return NULL;
44384 }
44385
44386
44387 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44388 PyObject *resultobj = 0;
44389 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44390 wxString *arg2 = 0 ;
44391 unsigned int arg3 ;
44392 PyObject *arg4 = (PyObject *) NULL ;
44393 int result;
44394 void *argp1 = 0 ;
44395 int res1 = 0 ;
44396 bool temp2 = false ;
44397 unsigned int val3 ;
44398 int ecode3 = 0 ;
44399 PyObject * obj0 = 0 ;
44400 PyObject * obj1 = 0 ;
44401 PyObject * obj2 = 0 ;
44402 PyObject * obj3 = 0 ;
44403 char * kwnames[] = {
44404 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44405 };
44406
44407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44409 if (!SWIG_IsOK(res1)) {
44410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44411 }
44412 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44413 {
44414 arg2 = wxString_in_helper(obj1);
44415 if (arg2 == NULL) SWIG_fail;
44416 temp2 = true;
44417 }
44418 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44419 if (!SWIG_IsOK(ecode3)) {
44420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44421 }
44422 arg3 = static_cast< unsigned int >(val3);
44423 if (obj3) {
44424 arg4 = obj3;
44425 }
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44429 wxPyEndAllowThreads(__tstate);
44430 if (PyErr_Occurred()) SWIG_fail;
44431 }
44432 resultobj = SWIG_From_int(static_cast< int >(result));
44433 {
44434 if (temp2)
44435 delete arg2;
44436 }
44437 return resultobj;
44438 fail:
44439 {
44440 if (temp2)
44441 delete arg2;
44442 }
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44448 PyObject *resultobj = 0;
44449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44450 void *argp1 = 0 ;
44451 int res1 = 0 ;
44452 PyObject *swig_obj[1] ;
44453
44454 if (!args) SWIG_fail;
44455 swig_obj[0] = args;
44456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44457 if (!SWIG_IsOK(res1)) {
44458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44459 }
44460 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44461 {
44462 PyThreadState* __tstate = wxPyBeginAllowThreads();
44463 (arg1)->Clear();
44464 wxPyEndAllowThreads(__tstate);
44465 if (PyErr_Occurred()) SWIG_fail;
44466 }
44467 resultobj = SWIG_Py_Void();
44468 return resultobj;
44469 fail:
44470 return NULL;
44471 }
44472
44473
44474 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44475 PyObject *resultobj = 0;
44476 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44477 unsigned int arg2 ;
44478 void *argp1 = 0 ;
44479 int res1 = 0 ;
44480 unsigned int val2 ;
44481 int ecode2 = 0 ;
44482 PyObject * obj0 = 0 ;
44483 PyObject * obj1 = 0 ;
44484 char * kwnames[] = {
44485 (char *) "self",(char *) "n", NULL
44486 };
44487
44488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44490 if (!SWIG_IsOK(res1)) {
44491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44492 }
44493 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44494 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44495 if (!SWIG_IsOK(ecode2)) {
44496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44497 }
44498 arg2 = static_cast< unsigned int >(val2);
44499 {
44500 PyThreadState* __tstate = wxPyBeginAllowThreads();
44501 (arg1)->Delete(arg2);
44502 wxPyEndAllowThreads(__tstate);
44503 if (PyErr_Occurred()) SWIG_fail;
44504 }
44505 resultobj = SWIG_Py_Void();
44506 return resultobj;
44507 fail:
44508 return NULL;
44509 }
44510
44511
44512 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44513 PyObject *resultobj = 0;
44514 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44515 unsigned int arg2 ;
44516 PyObject *result = 0 ;
44517 void *argp1 = 0 ;
44518 int res1 = 0 ;
44519 unsigned int val2 ;
44520 int ecode2 = 0 ;
44521 PyObject * obj0 = 0 ;
44522 PyObject * obj1 = 0 ;
44523 char * kwnames[] = {
44524 (char *) "self",(char *) "n", NULL
44525 };
44526
44527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44529 if (!SWIG_IsOK(res1)) {
44530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44531 }
44532 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44533 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44534 if (!SWIG_IsOK(ecode2)) {
44535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44536 }
44537 arg2 = static_cast< unsigned int >(val2);
44538 {
44539 PyThreadState* __tstate = wxPyBeginAllowThreads();
44540 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44541 wxPyEndAllowThreads(__tstate);
44542 if (PyErr_Occurred()) SWIG_fail;
44543 }
44544 resultobj = result;
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44552 PyObject *resultobj = 0;
44553 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44554 unsigned int arg2 ;
44555 PyObject *arg3 = (PyObject *) 0 ;
44556 void *argp1 = 0 ;
44557 int res1 = 0 ;
44558 unsigned int val2 ;
44559 int ecode2 = 0 ;
44560 PyObject * obj0 = 0 ;
44561 PyObject * obj1 = 0 ;
44562 PyObject * obj2 = 0 ;
44563 char * kwnames[] = {
44564 (char *) "self",(char *) "n",(char *) "clientData", NULL
44565 };
44566
44567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44569 if (!SWIG_IsOK(res1)) {
44570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44571 }
44572 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44573 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44574 if (!SWIG_IsOK(ecode2)) {
44575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44576 }
44577 arg2 = static_cast< unsigned int >(val2);
44578 arg3 = obj2;
44579 {
44580 PyThreadState* __tstate = wxPyBeginAllowThreads();
44581 wxItemContainer_SetClientData(arg1,arg2,arg3);
44582 wxPyEndAllowThreads(__tstate);
44583 if (PyErr_Occurred()) SWIG_fail;
44584 }
44585 resultobj = SWIG_Py_Void();
44586 return resultobj;
44587 fail:
44588 return NULL;
44589 }
44590
44591
44592 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44593 PyObject *resultobj = 0;
44594 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44595 unsigned int result;
44596 void *argp1 = 0 ;
44597 int res1 = 0 ;
44598 PyObject *swig_obj[1] ;
44599
44600 if (!args) SWIG_fail;
44601 swig_obj[0] = args;
44602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44605 }
44606 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44607 {
44608 PyThreadState* __tstate = wxPyBeginAllowThreads();
44609 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44610 wxPyEndAllowThreads(__tstate);
44611 if (PyErr_Occurred()) SWIG_fail;
44612 }
44613 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44614 return resultobj;
44615 fail:
44616 return NULL;
44617 }
44618
44619
44620 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44621 PyObject *resultobj = 0;
44622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44623 bool result;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 PyObject *swig_obj[1] ;
44627
44628 if (!args) SWIG_fail;
44629 swig_obj[0] = args;
44630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44633 }
44634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44635 {
44636 PyThreadState* __tstate = wxPyBeginAllowThreads();
44637 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44638 wxPyEndAllowThreads(__tstate);
44639 if (PyErr_Occurred()) SWIG_fail;
44640 }
44641 {
44642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44643 }
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44651 PyObject *resultobj = 0;
44652 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44653 unsigned int arg2 ;
44654 wxString result;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 unsigned int val2 ;
44658 int ecode2 = 0 ;
44659 PyObject * obj0 = 0 ;
44660 PyObject * obj1 = 0 ;
44661 char * kwnames[] = {
44662 (char *) "self",(char *) "n", NULL
44663 };
44664
44665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44667 if (!SWIG_IsOK(res1)) {
44668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44669 }
44670 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44671 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44672 if (!SWIG_IsOK(ecode2)) {
44673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44674 }
44675 arg2 = static_cast< unsigned int >(val2);
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44679 wxPyEndAllowThreads(__tstate);
44680 if (PyErr_Occurred()) SWIG_fail;
44681 }
44682 {
44683 #if wxUSE_UNICODE
44684 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44685 #else
44686 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44687 #endif
44688 }
44689 return resultobj;
44690 fail:
44691 return NULL;
44692 }
44693
44694
44695 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44696 PyObject *resultobj = 0;
44697 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44698 wxArrayString result;
44699 void *argp1 = 0 ;
44700 int res1 = 0 ;
44701 PyObject *swig_obj[1] ;
44702
44703 if (!args) SWIG_fail;
44704 swig_obj[0] = args;
44705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44706 if (!SWIG_IsOK(res1)) {
44707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44708 }
44709 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44710 {
44711 PyThreadState* __tstate = wxPyBeginAllowThreads();
44712 result = ((wxItemContainer const *)arg1)->GetStrings();
44713 wxPyEndAllowThreads(__tstate);
44714 if (PyErr_Occurred()) SWIG_fail;
44715 }
44716 {
44717 resultobj = wxArrayString2PyList_helper(result);
44718 }
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44726 PyObject *resultobj = 0;
44727 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44728 unsigned int arg2 ;
44729 wxString *arg3 = 0 ;
44730 void *argp1 = 0 ;
44731 int res1 = 0 ;
44732 unsigned int val2 ;
44733 int ecode2 = 0 ;
44734 bool temp3 = false ;
44735 PyObject * obj0 = 0 ;
44736 PyObject * obj1 = 0 ;
44737 PyObject * obj2 = 0 ;
44738 char * kwnames[] = {
44739 (char *) "self",(char *) "n",(char *) "s", NULL
44740 };
44741
44742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44744 if (!SWIG_IsOK(res1)) {
44745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44746 }
44747 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44748 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44749 if (!SWIG_IsOK(ecode2)) {
44750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44751 }
44752 arg2 = static_cast< unsigned int >(val2);
44753 {
44754 arg3 = wxString_in_helper(obj2);
44755 if (arg3 == NULL) SWIG_fail;
44756 temp3 = true;
44757 }
44758 {
44759 PyThreadState* __tstate = wxPyBeginAllowThreads();
44760 (arg1)->SetString(arg2,(wxString const &)*arg3);
44761 wxPyEndAllowThreads(__tstate);
44762 if (PyErr_Occurred()) SWIG_fail;
44763 }
44764 resultobj = SWIG_Py_Void();
44765 {
44766 if (temp3)
44767 delete arg3;
44768 }
44769 return resultobj;
44770 fail:
44771 {
44772 if (temp3)
44773 delete arg3;
44774 }
44775 return NULL;
44776 }
44777
44778
44779 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44780 PyObject *resultobj = 0;
44781 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44782 wxString *arg2 = 0 ;
44783 int result;
44784 void *argp1 = 0 ;
44785 int res1 = 0 ;
44786 bool temp2 = false ;
44787 PyObject * obj0 = 0 ;
44788 PyObject * obj1 = 0 ;
44789 char * kwnames[] = {
44790 (char *) "self",(char *) "s", NULL
44791 };
44792
44793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44795 if (!SWIG_IsOK(res1)) {
44796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44797 }
44798 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44799 {
44800 arg2 = wxString_in_helper(obj1);
44801 if (arg2 == NULL) SWIG_fail;
44802 temp2 = true;
44803 }
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44807 wxPyEndAllowThreads(__tstate);
44808 if (PyErr_Occurred()) SWIG_fail;
44809 }
44810 resultobj = SWIG_From_int(static_cast< int >(result));
44811 {
44812 if (temp2)
44813 delete arg2;
44814 }
44815 return resultobj;
44816 fail:
44817 {
44818 if (temp2)
44819 delete arg2;
44820 }
44821 return NULL;
44822 }
44823
44824
44825 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44826 PyObject *resultobj = 0;
44827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44828 int arg2 ;
44829 void *argp1 = 0 ;
44830 int res1 = 0 ;
44831 int val2 ;
44832 int ecode2 = 0 ;
44833 PyObject * obj0 = 0 ;
44834 PyObject * obj1 = 0 ;
44835 char * kwnames[] = {
44836 (char *) "self",(char *) "n", NULL
44837 };
44838
44839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44841 if (!SWIG_IsOK(res1)) {
44842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44843 }
44844 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44845 ecode2 = SWIG_AsVal_int(obj1, &val2);
44846 if (!SWIG_IsOK(ecode2)) {
44847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44848 }
44849 arg2 = static_cast< int >(val2);
44850 {
44851 PyThreadState* __tstate = wxPyBeginAllowThreads();
44852 (arg1)->SetSelection(arg2);
44853 wxPyEndAllowThreads(__tstate);
44854 if (PyErr_Occurred()) SWIG_fail;
44855 }
44856 resultobj = SWIG_Py_Void();
44857 return resultobj;
44858 fail:
44859 return NULL;
44860 }
44861
44862
44863 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44864 PyObject *resultobj = 0;
44865 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44866 int result;
44867 void *argp1 = 0 ;
44868 int res1 = 0 ;
44869 PyObject *swig_obj[1] ;
44870
44871 if (!args) SWIG_fail;
44872 swig_obj[0] = args;
44873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44874 if (!SWIG_IsOK(res1)) {
44875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44876 }
44877 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44878 {
44879 PyThreadState* __tstate = wxPyBeginAllowThreads();
44880 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44881 wxPyEndAllowThreads(__tstate);
44882 if (PyErr_Occurred()) SWIG_fail;
44883 }
44884 resultobj = SWIG_From_int(static_cast< int >(result));
44885 return resultobj;
44886 fail:
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj = 0;
44893 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44894 wxString *arg2 = 0 ;
44895 bool result;
44896 void *argp1 = 0 ;
44897 int res1 = 0 ;
44898 bool temp2 = false ;
44899 PyObject * obj0 = 0 ;
44900 PyObject * obj1 = 0 ;
44901 char * kwnames[] = {
44902 (char *) "self",(char *) "s", NULL
44903 };
44904
44905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44907 if (!SWIG_IsOK(res1)) {
44908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44909 }
44910 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44911 {
44912 arg2 = wxString_in_helper(obj1);
44913 if (arg2 == NULL) SWIG_fail;
44914 temp2 = true;
44915 }
44916 {
44917 PyThreadState* __tstate = wxPyBeginAllowThreads();
44918 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44919 wxPyEndAllowThreads(__tstate);
44920 if (PyErr_Occurred()) SWIG_fail;
44921 }
44922 {
44923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44924 }
44925 {
44926 if (temp2)
44927 delete arg2;
44928 }
44929 return resultobj;
44930 fail:
44931 {
44932 if (temp2)
44933 delete arg2;
44934 }
44935 return NULL;
44936 }
44937
44938
44939 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44940 PyObject *resultobj = 0;
44941 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44942 wxString result;
44943 void *argp1 = 0 ;
44944 int res1 = 0 ;
44945 PyObject *swig_obj[1] ;
44946
44947 if (!args) SWIG_fail;
44948 swig_obj[0] = args;
44949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44950 if (!SWIG_IsOK(res1)) {
44951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44952 }
44953 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44954 {
44955 PyThreadState* __tstate = wxPyBeginAllowThreads();
44956 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44957 wxPyEndAllowThreads(__tstate);
44958 if (PyErr_Occurred()) SWIG_fail;
44959 }
44960 {
44961 #if wxUSE_UNICODE
44962 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44963 #else
44964 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44965 #endif
44966 }
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44976 int arg2 ;
44977 void *argp1 = 0 ;
44978 int res1 = 0 ;
44979 int val2 ;
44980 int ecode2 = 0 ;
44981 PyObject * obj0 = 0 ;
44982 PyObject * obj1 = 0 ;
44983 char * kwnames[] = {
44984 (char *) "self",(char *) "n", NULL
44985 };
44986
44987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44989 if (!SWIG_IsOK(res1)) {
44990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44991 }
44992 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44993 ecode2 = SWIG_AsVal_int(obj1, &val2);
44994 if (!SWIG_IsOK(ecode2)) {
44995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44996 }
44997 arg2 = static_cast< int >(val2);
44998 {
44999 PyThreadState* __tstate = wxPyBeginAllowThreads();
45000 (arg1)->Select(arg2);
45001 wxPyEndAllowThreads(__tstate);
45002 if (PyErr_Occurred()) SWIG_fail;
45003 }
45004 resultobj = SWIG_Py_Void();
45005 return resultobj;
45006 fail:
45007 return NULL;
45008 }
45009
45010
45011 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45012 PyObject *obj;
45013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45014 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45015 return SWIG_Py_Void();
45016 }
45017
45018 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45019 PyObject *obj;
45020 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45021 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45022 return SWIG_Py_Void();
45023 }
45024
45025 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45026 PyObject *resultobj = 0;
45027 wxSizerItem *result = 0 ;
45028
45029 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 result = (wxSizerItem *)new wxSizerItem();
45033 wxPyEndAllowThreads(__tstate);
45034 if (PyErr_Occurred()) SWIG_fail;
45035 }
45036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45044 PyObject *resultobj = 0;
45045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45046 void *argp1 = 0 ;
45047 int res1 = 0 ;
45048 PyObject *swig_obj[1] ;
45049
45050 if (!args) SWIG_fail;
45051 swig_obj[0] = args;
45052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45055 }
45056 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 delete arg1;
45060
45061 wxPyEndAllowThreads(__tstate);
45062 if (PyErr_Occurred()) SWIG_fail;
45063 }
45064 resultobj = SWIG_Py_Void();
45065 return resultobj;
45066 fail:
45067 return NULL;
45068 }
45069
45070
45071 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45072 PyObject *resultobj = 0;
45073 wxWindow *arg1 = (wxWindow *) 0 ;
45074 int arg2 ;
45075 int arg3 ;
45076 int arg4 ;
45077 PyObject *arg5 = (PyObject *) NULL ;
45078 wxSizerItem *result = 0 ;
45079 void *argp1 = 0 ;
45080 int res1 = 0 ;
45081 int val2 ;
45082 int ecode2 = 0 ;
45083 int val3 ;
45084 int ecode3 = 0 ;
45085 int val4 ;
45086 int ecode4 = 0 ;
45087 PyObject * obj0 = 0 ;
45088 PyObject * obj1 = 0 ;
45089 PyObject * obj2 = 0 ;
45090 PyObject * obj3 = 0 ;
45091 PyObject * obj4 = 0 ;
45092 char * kwnames[] = {
45093 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45094 };
45095
45096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45098 if (!SWIG_IsOK(res1)) {
45099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45100 }
45101 arg1 = reinterpret_cast< wxWindow * >(argp1);
45102 ecode2 = SWIG_AsVal_int(obj1, &val2);
45103 if (!SWIG_IsOK(ecode2)) {
45104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45105 }
45106 arg2 = static_cast< int >(val2);
45107 ecode3 = SWIG_AsVal_int(obj2, &val3);
45108 if (!SWIG_IsOK(ecode3)) {
45109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45110 }
45111 arg3 = static_cast< int >(val3);
45112 ecode4 = SWIG_AsVal_int(obj3, &val4);
45113 if (!SWIG_IsOK(ecode4)) {
45114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45115 }
45116 arg4 = static_cast< int >(val4);
45117 if (obj4) {
45118 arg5 = obj4;
45119 }
45120 {
45121 PyThreadState* __tstate = wxPyBeginAllowThreads();
45122 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45123 wxPyEndAllowThreads(__tstate);
45124 if (PyErr_Occurred()) SWIG_fail;
45125 }
45126 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45127 return resultobj;
45128 fail:
45129 return NULL;
45130 }
45131
45132
45133 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45134 PyObject *resultobj = 0;
45135 int arg1 ;
45136 int arg2 ;
45137 int arg3 ;
45138 int arg4 ;
45139 int arg5 ;
45140 PyObject *arg6 = (PyObject *) NULL ;
45141 wxSizerItem *result = 0 ;
45142 int val1 ;
45143 int ecode1 = 0 ;
45144 int val2 ;
45145 int ecode2 = 0 ;
45146 int val3 ;
45147 int ecode3 = 0 ;
45148 int val4 ;
45149 int ecode4 = 0 ;
45150 int val5 ;
45151 int ecode5 = 0 ;
45152 PyObject * obj0 = 0 ;
45153 PyObject * obj1 = 0 ;
45154 PyObject * obj2 = 0 ;
45155 PyObject * obj3 = 0 ;
45156 PyObject * obj4 = 0 ;
45157 PyObject * obj5 = 0 ;
45158 char * kwnames[] = {
45159 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45160 };
45161
45162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45163 ecode1 = SWIG_AsVal_int(obj0, &val1);
45164 if (!SWIG_IsOK(ecode1)) {
45165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45166 }
45167 arg1 = static_cast< int >(val1);
45168 ecode2 = SWIG_AsVal_int(obj1, &val2);
45169 if (!SWIG_IsOK(ecode2)) {
45170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45171 }
45172 arg2 = static_cast< int >(val2);
45173 ecode3 = SWIG_AsVal_int(obj2, &val3);
45174 if (!SWIG_IsOK(ecode3)) {
45175 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45176 }
45177 arg3 = static_cast< int >(val3);
45178 ecode4 = SWIG_AsVal_int(obj3, &val4);
45179 if (!SWIG_IsOK(ecode4)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45181 }
45182 arg4 = static_cast< int >(val4);
45183 ecode5 = SWIG_AsVal_int(obj4, &val5);
45184 if (!SWIG_IsOK(ecode5)) {
45185 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45186 }
45187 arg5 = static_cast< int >(val5);
45188 if (obj5) {
45189 arg6 = obj5;
45190 }
45191 {
45192 PyThreadState* __tstate = wxPyBeginAllowThreads();
45193 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45194 wxPyEndAllowThreads(__tstate);
45195 if (PyErr_Occurred()) SWIG_fail;
45196 }
45197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45198 return resultobj;
45199 fail:
45200 return NULL;
45201 }
45202
45203
45204 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45205 PyObject *resultobj = 0;
45206 wxSizer *arg1 = (wxSizer *) 0 ;
45207 int arg2 ;
45208 int arg3 ;
45209 int arg4 ;
45210 PyObject *arg5 = (PyObject *) NULL ;
45211 wxSizerItem *result = 0 ;
45212 int res1 = 0 ;
45213 int val2 ;
45214 int ecode2 = 0 ;
45215 int val3 ;
45216 int ecode3 = 0 ;
45217 int val4 ;
45218 int ecode4 = 0 ;
45219 PyObject * obj0 = 0 ;
45220 PyObject * obj1 = 0 ;
45221 PyObject * obj2 = 0 ;
45222 PyObject * obj3 = 0 ;
45223 PyObject * obj4 = 0 ;
45224 char * kwnames[] = {
45225 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45226 };
45227
45228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45229 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45230 if (!SWIG_IsOK(res1)) {
45231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45232 }
45233 ecode2 = SWIG_AsVal_int(obj1, &val2);
45234 if (!SWIG_IsOK(ecode2)) {
45235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45236 }
45237 arg2 = static_cast< int >(val2);
45238 ecode3 = SWIG_AsVal_int(obj2, &val3);
45239 if (!SWIG_IsOK(ecode3)) {
45240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45241 }
45242 arg3 = static_cast< int >(val3);
45243 ecode4 = SWIG_AsVal_int(obj3, &val4);
45244 if (!SWIG_IsOK(ecode4)) {
45245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45246 }
45247 arg4 = static_cast< int >(val4);
45248 if (obj4) {
45249 arg5 = obj4;
45250 }
45251 {
45252 PyThreadState* __tstate = wxPyBeginAllowThreads();
45253 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45254 wxPyEndAllowThreads(__tstate);
45255 if (PyErr_Occurred()) SWIG_fail;
45256 }
45257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45258 return resultobj;
45259 fail:
45260 return NULL;
45261 }
45262
45263
45264 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45265 PyObject *resultobj = 0;
45266 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45267 void *argp1 = 0 ;
45268 int res1 = 0 ;
45269 PyObject *swig_obj[1] ;
45270
45271 if (!args) SWIG_fail;
45272 swig_obj[0] = args;
45273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45276 }
45277 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 (arg1)->DeleteWindows();
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 resultobj = SWIG_Py_Void();
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45292 PyObject *resultobj = 0;
45293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45294 void *argp1 = 0 ;
45295 int res1 = 0 ;
45296 PyObject *swig_obj[1] ;
45297
45298 if (!args) SWIG_fail;
45299 swig_obj[0] = args;
45300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45301 if (!SWIG_IsOK(res1)) {
45302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45303 }
45304 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45305 {
45306 PyThreadState* __tstate = wxPyBeginAllowThreads();
45307 (arg1)->DetachSizer();
45308 wxPyEndAllowThreads(__tstate);
45309 if (PyErr_Occurred()) SWIG_fail;
45310 }
45311 resultobj = SWIG_Py_Void();
45312 return resultobj;
45313 fail:
45314 return NULL;
45315 }
45316
45317
45318 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45319 PyObject *resultobj = 0;
45320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45321 wxSize result;
45322 void *argp1 = 0 ;
45323 int res1 = 0 ;
45324 PyObject *swig_obj[1] ;
45325
45326 if (!args) SWIG_fail;
45327 swig_obj[0] = args;
45328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45329 if (!SWIG_IsOK(res1)) {
45330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45331 }
45332 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45333 {
45334 PyThreadState* __tstate = wxPyBeginAllowThreads();
45335 result = (arg1)->GetSize();
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45340 return resultobj;
45341 fail:
45342 return NULL;
45343 }
45344
45345
45346 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45347 PyObject *resultobj = 0;
45348 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45349 wxSize result;
45350 void *argp1 = 0 ;
45351 int res1 = 0 ;
45352 PyObject *swig_obj[1] ;
45353
45354 if (!args) SWIG_fail;
45355 swig_obj[0] = args;
45356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45357 if (!SWIG_IsOK(res1)) {
45358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45359 }
45360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45361 {
45362 PyThreadState* __tstate = wxPyBeginAllowThreads();
45363 result = (arg1)->CalcMin();
45364 wxPyEndAllowThreads(__tstate);
45365 if (PyErr_Occurred()) SWIG_fail;
45366 }
45367 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45368 return resultobj;
45369 fail:
45370 return NULL;
45371 }
45372
45373
45374 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45375 PyObject *resultobj = 0;
45376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45377 wxPoint *arg2 = 0 ;
45378 wxSize *arg3 = 0 ;
45379 void *argp1 = 0 ;
45380 int res1 = 0 ;
45381 wxPoint temp2 ;
45382 wxSize temp3 ;
45383 PyObject * obj0 = 0 ;
45384 PyObject * obj1 = 0 ;
45385 PyObject * obj2 = 0 ;
45386 char * kwnames[] = {
45387 (char *) "self",(char *) "pos",(char *) "size", NULL
45388 };
45389
45390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45392 if (!SWIG_IsOK(res1)) {
45393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45394 }
45395 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45396 {
45397 arg2 = &temp2;
45398 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45399 }
45400 {
45401 arg3 = &temp3;
45402 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45403 }
45404 {
45405 PyThreadState* __tstate = wxPyBeginAllowThreads();
45406 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45407 wxPyEndAllowThreads(__tstate);
45408 if (PyErr_Occurred()) SWIG_fail;
45409 }
45410 resultobj = SWIG_Py_Void();
45411 return resultobj;
45412 fail:
45413 return NULL;
45414 }
45415
45416
45417 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45418 PyObject *resultobj = 0;
45419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45420 wxSize result;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 PyObject *swig_obj[1] ;
45424
45425 if (!args) SWIG_fail;
45426 swig_obj[0] = args;
45427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45430 }
45431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = (arg1)->GetMinSize();
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45439 return resultobj;
45440 fail:
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45446 PyObject *resultobj = 0;
45447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45448 wxSize result;
45449 void *argp1 = 0 ;
45450 int res1 = 0 ;
45451 PyObject *swig_obj[1] ;
45452
45453 if (!args) SWIG_fail;
45454 swig_obj[0] = args;
45455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45456 if (!SWIG_IsOK(res1)) {
45457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45458 }
45459 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45463 wxPyEndAllowThreads(__tstate);
45464 if (PyErr_Occurred()) SWIG_fail;
45465 }
45466 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45467 return resultobj;
45468 fail:
45469 return NULL;
45470 }
45471
45472
45473 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45474 PyObject *resultobj = 0;
45475 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45476 int arg2 ;
45477 int arg3 ;
45478 void *argp1 = 0 ;
45479 int res1 = 0 ;
45480 int val2 ;
45481 int ecode2 = 0 ;
45482 int val3 ;
45483 int ecode3 = 0 ;
45484 PyObject * obj0 = 0 ;
45485 PyObject * obj1 = 0 ;
45486 PyObject * obj2 = 0 ;
45487 char * kwnames[] = {
45488 (char *) "self",(char *) "x",(char *) "y", NULL
45489 };
45490
45491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45493 if (!SWIG_IsOK(res1)) {
45494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45495 }
45496 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45497 ecode2 = SWIG_AsVal_int(obj1, &val2);
45498 if (!SWIG_IsOK(ecode2)) {
45499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45500 }
45501 arg2 = static_cast< int >(val2);
45502 ecode3 = SWIG_AsVal_int(obj2, &val3);
45503 if (!SWIG_IsOK(ecode3)) {
45504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45505 }
45506 arg3 = static_cast< int >(val3);
45507 {
45508 PyThreadState* __tstate = wxPyBeginAllowThreads();
45509 (arg1)->SetInitSize(arg2,arg3);
45510 wxPyEndAllowThreads(__tstate);
45511 if (PyErr_Occurred()) SWIG_fail;
45512 }
45513 resultobj = SWIG_Py_Void();
45514 return resultobj;
45515 fail:
45516 return NULL;
45517 }
45518
45519
45520 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45521 PyObject *resultobj = 0;
45522 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45523 int arg2 ;
45524 int arg3 ;
45525 void *argp1 = 0 ;
45526 int res1 = 0 ;
45527 int val2 ;
45528 int ecode2 = 0 ;
45529 int val3 ;
45530 int ecode3 = 0 ;
45531 PyObject * obj0 = 0 ;
45532 PyObject * obj1 = 0 ;
45533 PyObject * obj2 = 0 ;
45534 char * kwnames[] = {
45535 (char *) "self",(char *) "width",(char *) "height", NULL
45536 };
45537
45538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45542 }
45543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45544 ecode2 = SWIG_AsVal_int(obj1, &val2);
45545 if (!SWIG_IsOK(ecode2)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45547 }
45548 arg2 = static_cast< int >(val2);
45549 ecode3 = SWIG_AsVal_int(obj2, &val3);
45550 if (!SWIG_IsOK(ecode3)) {
45551 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45552 }
45553 arg3 = static_cast< int >(val3);
45554 {
45555 PyThreadState* __tstate = wxPyBeginAllowThreads();
45556 (arg1)->SetRatio(arg2,arg3);
45557 wxPyEndAllowThreads(__tstate);
45558 if (PyErr_Occurred()) SWIG_fail;
45559 }
45560 resultobj = SWIG_Py_Void();
45561 return resultobj;
45562 fail:
45563 return NULL;
45564 }
45565
45566
45567 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45568 PyObject *resultobj = 0;
45569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45570 wxSize *arg2 = 0 ;
45571 void *argp1 = 0 ;
45572 int res1 = 0 ;
45573 wxSize temp2 ;
45574 PyObject * obj0 = 0 ;
45575 PyObject * obj1 = 0 ;
45576 char * kwnames[] = {
45577 (char *) "self",(char *) "size", NULL
45578 };
45579
45580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45582 if (!SWIG_IsOK(res1)) {
45583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45584 }
45585 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45586 {
45587 arg2 = &temp2;
45588 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45589 }
45590 {
45591 PyThreadState* __tstate = wxPyBeginAllowThreads();
45592 (arg1)->SetRatio((wxSize const &)*arg2);
45593 wxPyEndAllowThreads(__tstate);
45594 if (PyErr_Occurred()) SWIG_fail;
45595 }
45596 resultobj = SWIG_Py_Void();
45597 return resultobj;
45598 fail:
45599 return NULL;
45600 }
45601
45602
45603 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45604 PyObject *resultobj = 0;
45605 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45606 float arg2 ;
45607 void *argp1 = 0 ;
45608 int res1 = 0 ;
45609 float val2 ;
45610 int ecode2 = 0 ;
45611 PyObject * obj0 = 0 ;
45612 PyObject * obj1 = 0 ;
45613 char * kwnames[] = {
45614 (char *) "self",(char *) "ratio", NULL
45615 };
45616
45617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45619 if (!SWIG_IsOK(res1)) {
45620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45621 }
45622 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45623 ecode2 = SWIG_AsVal_float(obj1, &val2);
45624 if (!SWIG_IsOK(ecode2)) {
45625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45626 }
45627 arg2 = static_cast< float >(val2);
45628 {
45629 PyThreadState* __tstate = wxPyBeginAllowThreads();
45630 (arg1)->SetRatio(arg2);
45631 wxPyEndAllowThreads(__tstate);
45632 if (PyErr_Occurred()) SWIG_fail;
45633 }
45634 resultobj = SWIG_Py_Void();
45635 return resultobj;
45636 fail:
45637 return NULL;
45638 }
45639
45640
45641 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45642 PyObject *resultobj = 0;
45643 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45644 float result;
45645 void *argp1 = 0 ;
45646 int res1 = 0 ;
45647 PyObject *swig_obj[1] ;
45648
45649 if (!args) SWIG_fail;
45650 swig_obj[0] = args;
45651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45652 if (!SWIG_IsOK(res1)) {
45653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45654 }
45655 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45656 {
45657 PyThreadState* __tstate = wxPyBeginAllowThreads();
45658 result = (float)(arg1)->GetRatio();
45659 wxPyEndAllowThreads(__tstate);
45660 if (PyErr_Occurred()) SWIG_fail;
45661 }
45662 resultobj = SWIG_From_float(static_cast< float >(result));
45663 return resultobj;
45664 fail:
45665 return NULL;
45666 }
45667
45668
45669 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45670 PyObject *resultobj = 0;
45671 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45672 wxRect result;
45673 void *argp1 = 0 ;
45674 int res1 = 0 ;
45675 PyObject *swig_obj[1] ;
45676
45677 if (!args) SWIG_fail;
45678 swig_obj[0] = args;
45679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45680 if (!SWIG_IsOK(res1)) {
45681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45682 }
45683 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45684 {
45685 PyThreadState* __tstate = wxPyBeginAllowThreads();
45686 result = (arg1)->GetRect();
45687 wxPyEndAllowThreads(__tstate);
45688 if (PyErr_Occurred()) SWIG_fail;
45689 }
45690 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45691 return resultobj;
45692 fail:
45693 return NULL;
45694 }
45695
45696
45697 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45698 PyObject *resultobj = 0;
45699 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45700 bool result;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 PyObject *swig_obj[1] ;
45704
45705 if (!args) SWIG_fail;
45706 swig_obj[0] = args;
45707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45708 if (!SWIG_IsOK(res1)) {
45709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45710 }
45711 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 result = (bool)(arg1)->IsWindow();
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 {
45719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45720 }
45721 return resultobj;
45722 fail:
45723 return NULL;
45724 }
45725
45726
45727 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45728 PyObject *resultobj = 0;
45729 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45730 bool result;
45731 void *argp1 = 0 ;
45732 int res1 = 0 ;
45733 PyObject *swig_obj[1] ;
45734
45735 if (!args) SWIG_fail;
45736 swig_obj[0] = args;
45737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45738 if (!SWIG_IsOK(res1)) {
45739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45740 }
45741 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45742 {
45743 PyThreadState* __tstate = wxPyBeginAllowThreads();
45744 result = (bool)(arg1)->IsSizer();
45745 wxPyEndAllowThreads(__tstate);
45746 if (PyErr_Occurred()) SWIG_fail;
45747 }
45748 {
45749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45750 }
45751 return resultobj;
45752 fail:
45753 return NULL;
45754 }
45755
45756
45757 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45758 PyObject *resultobj = 0;
45759 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45760 bool result;
45761 void *argp1 = 0 ;
45762 int res1 = 0 ;
45763 PyObject *swig_obj[1] ;
45764
45765 if (!args) SWIG_fail;
45766 swig_obj[0] = args;
45767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45770 }
45771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45772 {
45773 PyThreadState* __tstate = wxPyBeginAllowThreads();
45774 result = (bool)(arg1)->IsSpacer();
45775 wxPyEndAllowThreads(__tstate);
45776 if (PyErr_Occurred()) SWIG_fail;
45777 }
45778 {
45779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45780 }
45781 return resultobj;
45782 fail:
45783 return NULL;
45784 }
45785
45786
45787 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45788 PyObject *resultobj = 0;
45789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45790 int arg2 ;
45791 void *argp1 = 0 ;
45792 int res1 = 0 ;
45793 int val2 ;
45794 int ecode2 = 0 ;
45795 PyObject * obj0 = 0 ;
45796 PyObject * obj1 = 0 ;
45797 char * kwnames[] = {
45798 (char *) "self",(char *) "proportion", NULL
45799 };
45800
45801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45803 if (!SWIG_IsOK(res1)) {
45804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45805 }
45806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45807 ecode2 = SWIG_AsVal_int(obj1, &val2);
45808 if (!SWIG_IsOK(ecode2)) {
45809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45810 }
45811 arg2 = static_cast< int >(val2);
45812 {
45813 PyThreadState* __tstate = wxPyBeginAllowThreads();
45814 (arg1)->SetProportion(arg2);
45815 wxPyEndAllowThreads(__tstate);
45816 if (PyErr_Occurred()) SWIG_fail;
45817 }
45818 resultobj = SWIG_Py_Void();
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45826 PyObject *resultobj = 0;
45827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45828 int result;
45829 void *argp1 = 0 ;
45830 int res1 = 0 ;
45831 PyObject *swig_obj[1] ;
45832
45833 if (!args) SWIG_fail;
45834 swig_obj[0] = args;
45835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45836 if (!SWIG_IsOK(res1)) {
45837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45838 }
45839 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 result = (int)(arg1)->GetProportion();
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 resultobj = SWIG_From_int(static_cast< int >(result));
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45854 PyObject *resultobj = 0;
45855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45856 int arg2 ;
45857 void *argp1 = 0 ;
45858 int res1 = 0 ;
45859 int val2 ;
45860 int ecode2 = 0 ;
45861 PyObject * obj0 = 0 ;
45862 PyObject * obj1 = 0 ;
45863 char * kwnames[] = {
45864 (char *) "self",(char *) "flag", NULL
45865 };
45866
45867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45869 if (!SWIG_IsOK(res1)) {
45870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45871 }
45872 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45873 ecode2 = SWIG_AsVal_int(obj1, &val2);
45874 if (!SWIG_IsOK(ecode2)) {
45875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45876 }
45877 arg2 = static_cast< int >(val2);
45878 {
45879 PyThreadState* __tstate = wxPyBeginAllowThreads();
45880 (arg1)->SetFlag(arg2);
45881 wxPyEndAllowThreads(__tstate);
45882 if (PyErr_Occurred()) SWIG_fail;
45883 }
45884 resultobj = SWIG_Py_Void();
45885 return resultobj;
45886 fail:
45887 return NULL;
45888 }
45889
45890
45891 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45892 PyObject *resultobj = 0;
45893 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45894 int result;
45895 void *argp1 = 0 ;
45896 int res1 = 0 ;
45897 PyObject *swig_obj[1] ;
45898
45899 if (!args) SWIG_fail;
45900 swig_obj[0] = args;
45901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45902 if (!SWIG_IsOK(res1)) {
45903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45904 }
45905 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45906 {
45907 PyThreadState* __tstate = wxPyBeginAllowThreads();
45908 result = (int)(arg1)->GetFlag();
45909 wxPyEndAllowThreads(__tstate);
45910 if (PyErr_Occurred()) SWIG_fail;
45911 }
45912 resultobj = SWIG_From_int(static_cast< int >(result));
45913 return resultobj;
45914 fail:
45915 return NULL;
45916 }
45917
45918
45919 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45920 PyObject *resultobj = 0;
45921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45922 int arg2 ;
45923 void *argp1 = 0 ;
45924 int res1 = 0 ;
45925 int val2 ;
45926 int ecode2 = 0 ;
45927 PyObject * obj0 = 0 ;
45928 PyObject * obj1 = 0 ;
45929 char * kwnames[] = {
45930 (char *) "self",(char *) "border", NULL
45931 };
45932
45933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45935 if (!SWIG_IsOK(res1)) {
45936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45937 }
45938 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45939 ecode2 = SWIG_AsVal_int(obj1, &val2);
45940 if (!SWIG_IsOK(ecode2)) {
45941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45942 }
45943 arg2 = static_cast< int >(val2);
45944 {
45945 PyThreadState* __tstate = wxPyBeginAllowThreads();
45946 (arg1)->SetBorder(arg2);
45947 wxPyEndAllowThreads(__tstate);
45948 if (PyErr_Occurred()) SWIG_fail;
45949 }
45950 resultobj = SWIG_Py_Void();
45951 return resultobj;
45952 fail:
45953 return NULL;
45954 }
45955
45956
45957 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45958 PyObject *resultobj = 0;
45959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45960 int result;
45961 void *argp1 = 0 ;
45962 int res1 = 0 ;
45963 PyObject *swig_obj[1] ;
45964
45965 if (!args) SWIG_fail;
45966 swig_obj[0] = args;
45967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45968 if (!SWIG_IsOK(res1)) {
45969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45970 }
45971 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45972 {
45973 PyThreadState* __tstate = wxPyBeginAllowThreads();
45974 result = (int)(arg1)->GetBorder();
45975 wxPyEndAllowThreads(__tstate);
45976 if (PyErr_Occurred()) SWIG_fail;
45977 }
45978 resultobj = SWIG_From_int(static_cast< int >(result));
45979 return resultobj;
45980 fail:
45981 return NULL;
45982 }
45983
45984
45985 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45986 PyObject *resultobj = 0;
45987 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45988 wxWindow *result = 0 ;
45989 void *argp1 = 0 ;
45990 int res1 = 0 ;
45991 PyObject *swig_obj[1] ;
45992
45993 if (!args) SWIG_fail;
45994 swig_obj[0] = args;
45995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45996 if (!SWIG_IsOK(res1)) {
45997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45998 }
45999 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46000 {
46001 PyThreadState* __tstate = wxPyBeginAllowThreads();
46002 result = (wxWindow *)(arg1)->GetWindow();
46003 wxPyEndAllowThreads(__tstate);
46004 if (PyErr_Occurred()) SWIG_fail;
46005 }
46006 {
46007 resultobj = wxPyMake_wxObject(result, 0);
46008 }
46009 return resultobj;
46010 fail:
46011 return NULL;
46012 }
46013
46014
46015 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46016 PyObject *resultobj = 0;
46017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46018 wxWindow *arg2 = (wxWindow *) 0 ;
46019 void *argp1 = 0 ;
46020 int res1 = 0 ;
46021 void *argp2 = 0 ;
46022 int res2 = 0 ;
46023 PyObject * obj0 = 0 ;
46024 PyObject * obj1 = 0 ;
46025 char * kwnames[] = {
46026 (char *) "self",(char *) "window", NULL
46027 };
46028
46029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46033 }
46034 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46036 if (!SWIG_IsOK(res2)) {
46037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46038 }
46039 arg2 = reinterpret_cast< wxWindow * >(argp2);
46040 {
46041 PyThreadState* __tstate = wxPyBeginAllowThreads();
46042 (arg1)->SetWindow(arg2);
46043 wxPyEndAllowThreads(__tstate);
46044 if (PyErr_Occurred()) SWIG_fail;
46045 }
46046 resultobj = SWIG_Py_Void();
46047 return resultobj;
46048 fail:
46049 return NULL;
46050 }
46051
46052
46053 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46054 PyObject *resultobj = 0;
46055 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46056 wxSizer *result = 0 ;
46057 void *argp1 = 0 ;
46058 int res1 = 0 ;
46059 PyObject *swig_obj[1] ;
46060
46061 if (!args) SWIG_fail;
46062 swig_obj[0] = args;
46063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46064 if (!SWIG_IsOK(res1)) {
46065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46066 }
46067 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46068 {
46069 PyThreadState* __tstate = wxPyBeginAllowThreads();
46070 result = (wxSizer *)(arg1)->GetSizer();
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 {
46075 resultobj = wxPyMake_wxObject(result, (bool)0);
46076 }
46077 return resultobj;
46078 fail:
46079 return NULL;
46080 }
46081
46082
46083 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46084 PyObject *resultobj = 0;
46085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46086 wxSizer *arg2 = (wxSizer *) 0 ;
46087 void *argp1 = 0 ;
46088 int res1 = 0 ;
46089 int res2 = 0 ;
46090 PyObject * obj0 = 0 ;
46091 PyObject * obj1 = 0 ;
46092 char * kwnames[] = {
46093 (char *) "self",(char *) "sizer", NULL
46094 };
46095
46096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46098 if (!SWIG_IsOK(res1)) {
46099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46100 }
46101 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46102 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46103 if (!SWIG_IsOK(res2)) {
46104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46105 }
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 (arg1)->SetSizer(arg2);
46109 wxPyEndAllowThreads(__tstate);
46110 if (PyErr_Occurred()) SWIG_fail;
46111 }
46112 resultobj = SWIG_Py_Void();
46113 return resultobj;
46114 fail:
46115 return NULL;
46116 }
46117
46118
46119 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46120 PyObject *resultobj = 0;
46121 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46122 wxSize *result = 0 ;
46123 void *argp1 = 0 ;
46124 int res1 = 0 ;
46125 PyObject *swig_obj[1] ;
46126
46127 if (!args) SWIG_fail;
46128 swig_obj[0] = args;
46129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46130 if (!SWIG_IsOK(res1)) {
46131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46132 }
46133 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46134 {
46135 PyThreadState* __tstate = wxPyBeginAllowThreads();
46136 {
46137 wxSize const &_result_ref = (arg1)->GetSpacer();
46138 result = (wxSize *) &_result_ref;
46139 }
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46153 wxSize *arg2 = 0 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 wxSize temp2 ;
46157 PyObject * obj0 = 0 ;
46158 PyObject * obj1 = 0 ;
46159 char * kwnames[] = {
46160 (char *) "self",(char *) "size", NULL
46161 };
46162
46163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46165 if (!SWIG_IsOK(res1)) {
46166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46167 }
46168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46169 {
46170 arg2 = &temp2;
46171 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46172 }
46173 {
46174 PyThreadState* __tstate = wxPyBeginAllowThreads();
46175 (arg1)->SetSpacer((wxSize const &)*arg2);
46176 wxPyEndAllowThreads(__tstate);
46177 if (PyErr_Occurred()) SWIG_fail;
46178 }
46179 resultobj = SWIG_Py_Void();
46180 return resultobj;
46181 fail:
46182 return NULL;
46183 }
46184
46185
46186 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46187 PyObject *resultobj = 0;
46188 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46189 bool arg2 ;
46190 void *argp1 = 0 ;
46191 int res1 = 0 ;
46192 bool val2 ;
46193 int ecode2 = 0 ;
46194 PyObject * obj0 = 0 ;
46195 PyObject * obj1 = 0 ;
46196 char * kwnames[] = {
46197 (char *) "self",(char *) "show", NULL
46198 };
46199
46200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46202 if (!SWIG_IsOK(res1)) {
46203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46204 }
46205 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46206 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46207 if (!SWIG_IsOK(ecode2)) {
46208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46209 }
46210 arg2 = static_cast< bool >(val2);
46211 {
46212 PyThreadState* __tstate = wxPyBeginAllowThreads();
46213 (arg1)->Show(arg2);
46214 wxPyEndAllowThreads(__tstate);
46215 if (PyErr_Occurred()) SWIG_fail;
46216 }
46217 resultobj = SWIG_Py_Void();
46218 return resultobj;
46219 fail:
46220 return NULL;
46221 }
46222
46223
46224 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46225 PyObject *resultobj = 0;
46226 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46227 bool result;
46228 void *argp1 = 0 ;
46229 int res1 = 0 ;
46230 PyObject *swig_obj[1] ;
46231
46232 if (!args) SWIG_fail;
46233 swig_obj[0] = args;
46234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46235 if (!SWIG_IsOK(res1)) {
46236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46237 }
46238 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46239 {
46240 PyThreadState* __tstate = wxPyBeginAllowThreads();
46241 result = (bool)(arg1)->IsShown();
46242 wxPyEndAllowThreads(__tstate);
46243 if (PyErr_Occurred()) SWIG_fail;
46244 }
46245 {
46246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46247 }
46248 return resultobj;
46249 fail:
46250 return NULL;
46251 }
46252
46253
46254 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46255 PyObject *resultobj = 0;
46256 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46257 wxPoint result;
46258 void *argp1 = 0 ;
46259 int res1 = 0 ;
46260 PyObject *swig_obj[1] ;
46261
46262 if (!args) SWIG_fail;
46263 swig_obj[0] = args;
46264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46265 if (!SWIG_IsOK(res1)) {
46266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46267 }
46268 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46269 {
46270 PyThreadState* __tstate = wxPyBeginAllowThreads();
46271 result = (arg1)->GetPosition();
46272 wxPyEndAllowThreads(__tstate);
46273 if (PyErr_Occurred()) SWIG_fail;
46274 }
46275 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46276 return resultobj;
46277 fail:
46278 return NULL;
46279 }
46280
46281
46282 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46283 PyObject *resultobj = 0;
46284 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46285 PyObject *result = 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, 0 | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46297 {
46298 PyThreadState* __tstate = wxPyBeginAllowThreads();
46299 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46300 wxPyEndAllowThreads(__tstate);
46301 if (PyErr_Occurred()) SWIG_fail;
46302 }
46303 resultobj = result;
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46313 PyObject *arg2 = (PyObject *) 0 ;
46314 void *argp1 = 0 ;
46315 int res1 = 0 ;
46316 PyObject * obj0 = 0 ;
46317 PyObject * obj1 = 0 ;
46318 char * kwnames[] = {
46319 (char *) "self",(char *) "userData", NULL
46320 };
46321
46322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46324 if (!SWIG_IsOK(res1)) {
46325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46326 }
46327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46328 arg2 = obj1;
46329 {
46330 PyThreadState* __tstate = wxPyBeginAllowThreads();
46331 wxSizerItem_SetUserData(arg1,arg2);
46332 wxPyEndAllowThreads(__tstate);
46333 if (PyErr_Occurred()) SWIG_fail;
46334 }
46335 resultobj = SWIG_Py_Void();
46336 return resultobj;
46337 fail:
46338 return NULL;
46339 }
46340
46341
46342 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46343 PyObject *obj;
46344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46345 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46346 return SWIG_Py_Void();
46347 }
46348
46349 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46350 return SWIG_Python_InitShadowInstance(args);
46351 }
46352
46353 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46354 PyObject *resultobj = 0;
46355 wxSizer *arg1 = (wxSizer *) 0 ;
46356 void *argp1 = 0 ;
46357 int res1 = 0 ;
46358 PyObject *swig_obj[1] ;
46359
46360 if (!args) SWIG_fail;
46361 swig_obj[0] = args;
46362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46363 if (!SWIG_IsOK(res1)) {
46364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46365 }
46366 arg1 = reinterpret_cast< wxSizer * >(argp1);
46367 {
46368 PyThreadState* __tstate = wxPyBeginAllowThreads();
46369 delete arg1;
46370
46371 wxPyEndAllowThreads(__tstate);
46372 if (PyErr_Occurred()) SWIG_fail;
46373 }
46374 resultobj = SWIG_Py_Void();
46375 return resultobj;
46376 fail:
46377 return NULL;
46378 }
46379
46380
46381 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46382 PyObject *resultobj = 0;
46383 wxSizer *arg1 = (wxSizer *) 0 ;
46384 PyObject *arg2 = (PyObject *) 0 ;
46385 void *argp1 = 0 ;
46386 int res1 = 0 ;
46387 PyObject * obj0 = 0 ;
46388 PyObject * obj1 = 0 ;
46389 char * kwnames[] = {
46390 (char *) "self",(char *) "_self", NULL
46391 };
46392
46393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46395 if (!SWIG_IsOK(res1)) {
46396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46397 }
46398 arg1 = reinterpret_cast< wxSizer * >(argp1);
46399 arg2 = obj1;
46400 {
46401 PyThreadState* __tstate = wxPyBeginAllowThreads();
46402 wxSizer__setOORInfo(arg1,arg2);
46403 wxPyEndAllowThreads(__tstate);
46404 if (PyErr_Occurred()) SWIG_fail;
46405 }
46406 resultobj = SWIG_Py_Void();
46407 return resultobj;
46408 fail:
46409 return NULL;
46410 }
46411
46412
46413 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46414 PyObject *resultobj = 0;
46415 wxSizer *arg1 = (wxSizer *) 0 ;
46416 PyObject *arg2 = (PyObject *) 0 ;
46417 int arg3 = (int) 0 ;
46418 int arg4 = (int) 0 ;
46419 int arg5 = (int) 0 ;
46420 PyObject *arg6 = (PyObject *) NULL ;
46421 wxSizerItem *result = 0 ;
46422 void *argp1 = 0 ;
46423 int res1 = 0 ;
46424 int val3 ;
46425 int ecode3 = 0 ;
46426 int val4 ;
46427 int ecode4 = 0 ;
46428 int val5 ;
46429 int ecode5 = 0 ;
46430 PyObject * obj0 = 0 ;
46431 PyObject * obj1 = 0 ;
46432 PyObject * obj2 = 0 ;
46433 PyObject * obj3 = 0 ;
46434 PyObject * obj4 = 0 ;
46435 PyObject * obj5 = 0 ;
46436 char * kwnames[] = {
46437 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46438 };
46439
46440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46442 if (!SWIG_IsOK(res1)) {
46443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46444 }
46445 arg1 = reinterpret_cast< wxSizer * >(argp1);
46446 arg2 = obj1;
46447 if (obj2) {
46448 ecode3 = SWIG_AsVal_int(obj2, &val3);
46449 if (!SWIG_IsOK(ecode3)) {
46450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46451 }
46452 arg3 = static_cast< int >(val3);
46453 }
46454 if (obj3) {
46455 ecode4 = SWIG_AsVal_int(obj3, &val4);
46456 if (!SWIG_IsOK(ecode4)) {
46457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46458 }
46459 arg4 = static_cast< int >(val4);
46460 }
46461 if (obj4) {
46462 ecode5 = SWIG_AsVal_int(obj4, &val5);
46463 if (!SWIG_IsOK(ecode5)) {
46464 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46465 }
46466 arg5 = static_cast< int >(val5);
46467 }
46468 if (obj5) {
46469 arg6 = obj5;
46470 }
46471 {
46472 PyThreadState* __tstate = wxPyBeginAllowThreads();
46473 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46474 wxPyEndAllowThreads(__tstate);
46475 if (PyErr_Occurred()) SWIG_fail;
46476 }
46477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46478 return resultobj;
46479 fail:
46480 return NULL;
46481 }
46482
46483
46484 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46485 PyObject *resultobj = 0;
46486 wxSizer *arg1 = (wxSizer *) 0 ;
46487 int arg2 ;
46488 PyObject *arg3 = (PyObject *) 0 ;
46489 int arg4 = (int) 0 ;
46490 int arg5 = (int) 0 ;
46491 int arg6 = (int) 0 ;
46492 PyObject *arg7 = (PyObject *) NULL ;
46493 wxSizerItem *result = 0 ;
46494 void *argp1 = 0 ;
46495 int res1 = 0 ;
46496 int val2 ;
46497 int ecode2 = 0 ;
46498 int val4 ;
46499 int ecode4 = 0 ;
46500 int val5 ;
46501 int ecode5 = 0 ;
46502 int val6 ;
46503 int ecode6 = 0 ;
46504 PyObject * obj0 = 0 ;
46505 PyObject * obj1 = 0 ;
46506 PyObject * obj2 = 0 ;
46507 PyObject * obj3 = 0 ;
46508 PyObject * obj4 = 0 ;
46509 PyObject * obj5 = 0 ;
46510 PyObject * obj6 = 0 ;
46511 char * kwnames[] = {
46512 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46513 };
46514
46515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46517 if (!SWIG_IsOK(res1)) {
46518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46519 }
46520 arg1 = reinterpret_cast< wxSizer * >(argp1);
46521 ecode2 = SWIG_AsVal_int(obj1, &val2);
46522 if (!SWIG_IsOK(ecode2)) {
46523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46524 }
46525 arg2 = static_cast< int >(val2);
46526 arg3 = obj2;
46527 if (obj3) {
46528 ecode4 = SWIG_AsVal_int(obj3, &val4);
46529 if (!SWIG_IsOK(ecode4)) {
46530 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46531 }
46532 arg4 = static_cast< int >(val4);
46533 }
46534 if (obj4) {
46535 ecode5 = SWIG_AsVal_int(obj4, &val5);
46536 if (!SWIG_IsOK(ecode5)) {
46537 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46538 }
46539 arg5 = static_cast< int >(val5);
46540 }
46541 if (obj5) {
46542 ecode6 = SWIG_AsVal_int(obj5, &val6);
46543 if (!SWIG_IsOK(ecode6)) {
46544 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46545 }
46546 arg6 = static_cast< int >(val6);
46547 }
46548 if (obj6) {
46549 arg7 = obj6;
46550 }
46551 {
46552 PyThreadState* __tstate = wxPyBeginAllowThreads();
46553 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46554 wxPyEndAllowThreads(__tstate);
46555 if (PyErr_Occurred()) SWIG_fail;
46556 }
46557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46558 return resultobj;
46559 fail:
46560 return NULL;
46561 }
46562
46563
46564 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46565 PyObject *resultobj = 0;
46566 wxSizer *arg1 = (wxSizer *) 0 ;
46567 PyObject *arg2 = (PyObject *) 0 ;
46568 int arg3 = (int) 0 ;
46569 int arg4 = (int) 0 ;
46570 int arg5 = (int) 0 ;
46571 PyObject *arg6 = (PyObject *) NULL ;
46572 wxSizerItem *result = 0 ;
46573 void *argp1 = 0 ;
46574 int res1 = 0 ;
46575 int val3 ;
46576 int ecode3 = 0 ;
46577 int val4 ;
46578 int ecode4 = 0 ;
46579 int val5 ;
46580 int ecode5 = 0 ;
46581 PyObject * obj0 = 0 ;
46582 PyObject * obj1 = 0 ;
46583 PyObject * obj2 = 0 ;
46584 PyObject * obj3 = 0 ;
46585 PyObject * obj4 = 0 ;
46586 PyObject * obj5 = 0 ;
46587 char * kwnames[] = {
46588 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46589 };
46590
46591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46593 if (!SWIG_IsOK(res1)) {
46594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46595 }
46596 arg1 = reinterpret_cast< wxSizer * >(argp1);
46597 arg2 = obj1;
46598 if (obj2) {
46599 ecode3 = SWIG_AsVal_int(obj2, &val3);
46600 if (!SWIG_IsOK(ecode3)) {
46601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46602 }
46603 arg3 = static_cast< int >(val3);
46604 }
46605 if (obj3) {
46606 ecode4 = SWIG_AsVal_int(obj3, &val4);
46607 if (!SWIG_IsOK(ecode4)) {
46608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46609 }
46610 arg4 = static_cast< int >(val4);
46611 }
46612 if (obj4) {
46613 ecode5 = SWIG_AsVal_int(obj4, &val5);
46614 if (!SWIG_IsOK(ecode5)) {
46615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46616 }
46617 arg5 = static_cast< int >(val5);
46618 }
46619 if (obj5) {
46620 arg6 = obj5;
46621 }
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46636 PyObject *resultobj = 0;
46637 wxSizer *arg1 = (wxSizer *) 0 ;
46638 PyObject *arg2 = (PyObject *) 0 ;
46639 bool result;
46640 void *argp1 = 0 ;
46641 int res1 = 0 ;
46642 PyObject * obj0 = 0 ;
46643 PyObject * obj1 = 0 ;
46644 char * kwnames[] = {
46645 (char *) "self",(char *) "item", NULL
46646 };
46647
46648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46650 if (!SWIG_IsOK(res1)) {
46651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46652 }
46653 arg1 = reinterpret_cast< wxSizer * >(argp1);
46654 arg2 = obj1;
46655 {
46656 PyThreadState* __tstate = wxPyBeginAllowThreads();
46657 result = (bool)wxSizer_Remove(arg1,arg2);
46658 wxPyEndAllowThreads(__tstate);
46659 if (PyErr_Occurred()) SWIG_fail;
46660 }
46661 {
46662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46663 }
46664 return resultobj;
46665 fail:
46666 return NULL;
46667 }
46668
46669
46670 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46671 PyObject *resultobj = 0;
46672 wxSizer *arg1 = (wxSizer *) 0 ;
46673 PyObject *arg2 = (PyObject *) 0 ;
46674 bool result;
46675 void *argp1 = 0 ;
46676 int res1 = 0 ;
46677 PyObject * obj0 = 0 ;
46678 PyObject * obj1 = 0 ;
46679 char * kwnames[] = {
46680 (char *) "self",(char *) "item", NULL
46681 };
46682
46683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46685 if (!SWIG_IsOK(res1)) {
46686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46687 }
46688 arg1 = reinterpret_cast< wxSizer * >(argp1);
46689 arg2 = obj1;
46690 {
46691 PyThreadState* __tstate = wxPyBeginAllowThreads();
46692 result = (bool)wxSizer_Detach(arg1,arg2);
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 {
46697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46698 }
46699 return resultobj;
46700 fail:
46701 return NULL;
46702 }
46703
46704
46705 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46706 PyObject *resultobj = 0;
46707 wxSizer *arg1 = (wxSizer *) 0 ;
46708 PyObject *arg2 = (PyObject *) 0 ;
46709 wxSizerItem *result = 0 ;
46710 void *argp1 = 0 ;
46711 int res1 = 0 ;
46712 PyObject * obj0 = 0 ;
46713 PyObject * obj1 = 0 ;
46714 char * kwnames[] = {
46715 (char *) "self",(char *) "item", NULL
46716 };
46717
46718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46720 if (!SWIG_IsOK(res1)) {
46721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46722 }
46723 arg1 = reinterpret_cast< wxSizer * >(argp1);
46724 arg2 = obj1;
46725 {
46726 PyThreadState* __tstate = wxPyBeginAllowThreads();
46727 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46728 wxPyEndAllowThreads(__tstate);
46729 if (PyErr_Occurred()) SWIG_fail;
46730 }
46731 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46732 return resultobj;
46733 fail:
46734 return NULL;
46735 }
46736
46737
46738 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46739 PyObject *resultobj = 0;
46740 wxSizer *arg1 = (wxSizer *) 0 ;
46741 PyObject *arg2 = (PyObject *) 0 ;
46742 wxSize *arg3 = 0 ;
46743 void *argp1 = 0 ;
46744 int res1 = 0 ;
46745 wxSize temp3 ;
46746 PyObject * obj0 = 0 ;
46747 PyObject * obj1 = 0 ;
46748 PyObject * obj2 = 0 ;
46749 char * kwnames[] = {
46750 (char *) "self",(char *) "item",(char *) "size", NULL
46751 };
46752
46753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46755 if (!SWIG_IsOK(res1)) {
46756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46757 }
46758 arg1 = reinterpret_cast< wxSizer * >(argp1);
46759 arg2 = obj1;
46760 {
46761 arg3 = &temp3;
46762 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46763 }
46764 {
46765 PyThreadState* __tstate = wxPyBeginAllowThreads();
46766 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46767 wxPyEndAllowThreads(__tstate);
46768 if (PyErr_Occurred()) SWIG_fail;
46769 }
46770 resultobj = SWIG_Py_Void();
46771 return resultobj;
46772 fail:
46773 return NULL;
46774 }
46775
46776
46777 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46778 PyObject *resultobj = 0;
46779 wxSizer *arg1 = (wxSizer *) 0 ;
46780 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46781 wxSizerItem *result = 0 ;
46782 void *argp1 = 0 ;
46783 int res1 = 0 ;
46784 int res2 = 0 ;
46785 PyObject * obj0 = 0 ;
46786 PyObject * obj1 = 0 ;
46787 char * kwnames[] = {
46788 (char *) "self",(char *) "item", NULL
46789 };
46790
46791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46793 if (!SWIG_IsOK(res1)) {
46794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46795 }
46796 arg1 = reinterpret_cast< wxSizer * >(argp1);
46797 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46798 if (!SWIG_IsOK(res2)) {
46799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46800 }
46801 {
46802 PyThreadState* __tstate = wxPyBeginAllowThreads();
46803 result = (wxSizerItem *)(arg1)->Add(arg2);
46804 wxPyEndAllowThreads(__tstate);
46805 if (PyErr_Occurred()) SWIG_fail;
46806 }
46807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46808 return resultobj;
46809 fail:
46810 return NULL;
46811 }
46812
46813
46814 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46815 PyObject *resultobj = 0;
46816 wxSizer *arg1 = (wxSizer *) 0 ;
46817 size_t arg2 ;
46818 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46819 wxSizerItem *result = 0 ;
46820 void *argp1 = 0 ;
46821 int res1 = 0 ;
46822 size_t val2 ;
46823 int ecode2 = 0 ;
46824 int res3 = 0 ;
46825 PyObject * obj0 = 0 ;
46826 PyObject * obj1 = 0 ;
46827 PyObject * obj2 = 0 ;
46828 char * kwnames[] = {
46829 (char *) "self",(char *) "index",(char *) "item", NULL
46830 };
46831
46832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46834 if (!SWIG_IsOK(res1)) {
46835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46836 }
46837 arg1 = reinterpret_cast< wxSizer * >(argp1);
46838 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46839 if (!SWIG_IsOK(ecode2)) {
46840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46841 }
46842 arg2 = static_cast< size_t >(val2);
46843 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46844 if (!SWIG_IsOK(res3)) {
46845 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46846 }
46847 {
46848 PyThreadState* __tstate = wxPyBeginAllowThreads();
46849 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46850 wxPyEndAllowThreads(__tstate);
46851 if (PyErr_Occurred()) SWIG_fail;
46852 }
46853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46854 return resultobj;
46855 fail:
46856 return NULL;
46857 }
46858
46859
46860 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46861 PyObject *resultobj = 0;
46862 wxSizer *arg1 = (wxSizer *) 0 ;
46863 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46864 wxSizerItem *result = 0 ;
46865 void *argp1 = 0 ;
46866 int res1 = 0 ;
46867 int res2 = 0 ;
46868 PyObject * obj0 = 0 ;
46869 PyObject * obj1 = 0 ;
46870 char * kwnames[] = {
46871 (char *) "self",(char *) "item", NULL
46872 };
46873
46874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46876 if (!SWIG_IsOK(res1)) {
46877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46878 }
46879 arg1 = reinterpret_cast< wxSizer * >(argp1);
46880 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46881 if (!SWIG_IsOK(res2)) {
46882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46883 }
46884 {
46885 PyThreadState* __tstate = wxPyBeginAllowThreads();
46886 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46887 wxPyEndAllowThreads(__tstate);
46888 if (PyErr_Occurred()) SWIG_fail;
46889 }
46890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46891 return resultobj;
46892 fail:
46893 return NULL;
46894 }
46895
46896
46897 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46898 PyObject *resultobj = 0;
46899 wxSizer *arg1 = (wxSizer *) 0 ;
46900 int arg2 ;
46901 int arg3 ;
46902 int arg4 ;
46903 int arg5 ;
46904 void *argp1 = 0 ;
46905 int res1 = 0 ;
46906 int val2 ;
46907 int ecode2 = 0 ;
46908 int val3 ;
46909 int ecode3 = 0 ;
46910 int val4 ;
46911 int ecode4 = 0 ;
46912 int val5 ;
46913 int ecode5 = 0 ;
46914 PyObject * obj0 = 0 ;
46915 PyObject * obj1 = 0 ;
46916 PyObject * obj2 = 0 ;
46917 PyObject * obj3 = 0 ;
46918 PyObject * obj4 = 0 ;
46919 char * kwnames[] = {
46920 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46921 };
46922
46923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46925 if (!SWIG_IsOK(res1)) {
46926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46927 }
46928 arg1 = reinterpret_cast< wxSizer * >(argp1);
46929 ecode2 = SWIG_AsVal_int(obj1, &val2);
46930 if (!SWIG_IsOK(ecode2)) {
46931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46932 }
46933 arg2 = static_cast< int >(val2);
46934 ecode3 = SWIG_AsVal_int(obj2, &val3);
46935 if (!SWIG_IsOK(ecode3)) {
46936 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46937 }
46938 arg3 = static_cast< int >(val3);
46939 ecode4 = SWIG_AsVal_int(obj3, &val4);
46940 if (!SWIG_IsOK(ecode4)) {
46941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46942 }
46943 arg4 = static_cast< int >(val4);
46944 ecode5 = SWIG_AsVal_int(obj4, &val5);
46945 if (!SWIG_IsOK(ecode5)) {
46946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46947 }
46948 arg5 = static_cast< int >(val5);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46952 wxPyEndAllowThreads(__tstate);
46953 if (PyErr_Occurred()) SWIG_fail;
46954 }
46955 resultobj = SWIG_Py_Void();
46956 return resultobj;
46957 fail:
46958 return NULL;
46959 }
46960
46961
46962 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46963 PyObject *resultobj = 0;
46964 wxSizer *arg1 = (wxSizer *) 0 ;
46965 wxSize *arg2 = 0 ;
46966 void *argp1 = 0 ;
46967 int res1 = 0 ;
46968 wxSize temp2 ;
46969 PyObject * obj0 = 0 ;
46970 PyObject * obj1 = 0 ;
46971 char * kwnames[] = {
46972 (char *) "self",(char *) "size", NULL
46973 };
46974
46975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46977 if (!SWIG_IsOK(res1)) {
46978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46979 }
46980 arg1 = reinterpret_cast< wxSizer * >(argp1);
46981 {
46982 arg2 = &temp2;
46983 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46984 }
46985 {
46986 PyThreadState* __tstate = wxPyBeginAllowThreads();
46987 (arg1)->SetMinSize((wxSize const &)*arg2);
46988 wxPyEndAllowThreads(__tstate);
46989 if (PyErr_Occurred()) SWIG_fail;
46990 }
46991 resultobj = SWIG_Py_Void();
46992 return resultobj;
46993 fail:
46994 return NULL;
46995 }
46996
46997
46998 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46999 PyObject *resultobj = 0;
47000 wxSizer *arg1 = (wxSizer *) 0 ;
47001 wxSize result;
47002 void *argp1 = 0 ;
47003 int res1 = 0 ;
47004 PyObject *swig_obj[1] ;
47005
47006 if (!args) SWIG_fail;
47007 swig_obj[0] = args;
47008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47009 if (!SWIG_IsOK(res1)) {
47010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47011 }
47012 arg1 = reinterpret_cast< wxSizer * >(argp1);
47013 {
47014 PyThreadState* __tstate = wxPyBeginAllowThreads();
47015 result = (arg1)->GetSize();
47016 wxPyEndAllowThreads(__tstate);
47017 if (PyErr_Occurred()) SWIG_fail;
47018 }
47019 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47027 PyObject *resultobj = 0;
47028 wxSizer *arg1 = (wxSizer *) 0 ;
47029 wxPoint result;
47030 void *argp1 = 0 ;
47031 int res1 = 0 ;
47032 PyObject *swig_obj[1] ;
47033
47034 if (!args) SWIG_fail;
47035 swig_obj[0] = args;
47036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47037 if (!SWIG_IsOK(res1)) {
47038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47039 }
47040 arg1 = reinterpret_cast< wxSizer * >(argp1);
47041 {
47042 PyThreadState* __tstate = wxPyBeginAllowThreads();
47043 result = (arg1)->GetPosition();
47044 wxPyEndAllowThreads(__tstate);
47045 if (PyErr_Occurred()) SWIG_fail;
47046 }
47047 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47048 return resultobj;
47049 fail:
47050 return NULL;
47051 }
47052
47053
47054 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47055 PyObject *resultobj = 0;
47056 wxSizer *arg1 = (wxSizer *) 0 ;
47057 wxSize result;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 PyObject *swig_obj[1] ;
47061
47062 if (!args) SWIG_fail;
47063 swig_obj[0] = args;
47064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47067 }
47068 arg1 = reinterpret_cast< wxSizer * >(argp1);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 result = (arg1)->GetMinSize();
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47083 PyObject *resultobj = 0;
47084 wxSizer *arg1 = (wxSizer *) 0 ;
47085 void *argp1 = 0 ;
47086 int res1 = 0 ;
47087 PyObject *swig_obj[1] ;
47088
47089 if (!args) SWIG_fail;
47090 swig_obj[0] = args;
47091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47092 if (!SWIG_IsOK(res1)) {
47093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47094 }
47095 arg1 = reinterpret_cast< wxSizer * >(argp1);
47096 {
47097 PyThreadState* __tstate = wxPyBeginAllowThreads();
47098 (arg1)->RecalcSizes();
47099 wxPyEndAllowThreads(__tstate);
47100 if (PyErr_Occurred()) SWIG_fail;
47101 }
47102 resultobj = SWIG_Py_Void();
47103 return resultobj;
47104 fail:
47105 return NULL;
47106 }
47107
47108
47109 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47110 PyObject *resultobj = 0;
47111 wxSizer *arg1 = (wxSizer *) 0 ;
47112 wxSize result;
47113 void *argp1 = 0 ;
47114 int res1 = 0 ;
47115 PyObject *swig_obj[1] ;
47116
47117 if (!args) SWIG_fail;
47118 swig_obj[0] = args;
47119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47120 if (!SWIG_IsOK(res1)) {
47121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47122 }
47123 arg1 = reinterpret_cast< wxSizer * >(argp1);
47124 {
47125 PyThreadState* __tstate = wxPyBeginAllowThreads();
47126 result = (arg1)->CalcMin();
47127 wxPyEndAllowThreads(__tstate);
47128 if (PyErr_Occurred()) SWIG_fail;
47129 }
47130 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47131 return resultobj;
47132 fail:
47133 return NULL;
47134 }
47135
47136
47137 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47138 PyObject *resultobj = 0;
47139 wxSizer *arg1 = (wxSizer *) 0 ;
47140 void *argp1 = 0 ;
47141 int res1 = 0 ;
47142 PyObject *swig_obj[1] ;
47143
47144 if (!args) SWIG_fail;
47145 swig_obj[0] = args;
47146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47147 if (!SWIG_IsOK(res1)) {
47148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47149 }
47150 arg1 = reinterpret_cast< wxSizer * >(argp1);
47151 {
47152 PyThreadState* __tstate = wxPyBeginAllowThreads();
47153 (arg1)->Layout();
47154 wxPyEndAllowThreads(__tstate);
47155 if (PyErr_Occurred()) SWIG_fail;
47156 }
47157 resultobj = SWIG_Py_Void();
47158 return resultobj;
47159 fail:
47160 return NULL;
47161 }
47162
47163
47164 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47165 PyObject *resultobj = 0;
47166 wxSizer *arg1 = (wxSizer *) 0 ;
47167 wxWindow *arg2 = (wxWindow *) 0 ;
47168 wxSize result;
47169 void *argp1 = 0 ;
47170 int res1 = 0 ;
47171 void *argp2 = 0 ;
47172 int res2 = 0 ;
47173 PyObject * obj0 = 0 ;
47174 PyObject * obj1 = 0 ;
47175 char * kwnames[] = {
47176 (char *) "self",(char *) "window", NULL
47177 };
47178
47179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47181 if (!SWIG_IsOK(res1)) {
47182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47183 }
47184 arg1 = reinterpret_cast< wxSizer * >(argp1);
47185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47186 if (!SWIG_IsOK(res2)) {
47187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47188 }
47189 arg2 = reinterpret_cast< wxWindow * >(argp2);
47190 {
47191 PyThreadState* __tstate = wxPyBeginAllowThreads();
47192 result = (arg1)->Fit(arg2);
47193 wxPyEndAllowThreads(__tstate);
47194 if (PyErr_Occurred()) SWIG_fail;
47195 }
47196 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47197 return resultobj;
47198 fail:
47199 return NULL;
47200 }
47201
47202
47203 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47204 PyObject *resultobj = 0;
47205 wxSizer *arg1 = (wxSizer *) 0 ;
47206 wxWindow *arg2 = (wxWindow *) 0 ;
47207 void *argp1 = 0 ;
47208 int res1 = 0 ;
47209 void *argp2 = 0 ;
47210 int res2 = 0 ;
47211 PyObject * obj0 = 0 ;
47212 PyObject * obj1 = 0 ;
47213 char * kwnames[] = {
47214 (char *) "self",(char *) "window", NULL
47215 };
47216
47217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47219 if (!SWIG_IsOK(res1)) {
47220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47221 }
47222 arg1 = reinterpret_cast< wxSizer * >(argp1);
47223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47224 if (!SWIG_IsOK(res2)) {
47225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47226 }
47227 arg2 = reinterpret_cast< wxWindow * >(argp2);
47228 {
47229 PyThreadState* __tstate = wxPyBeginAllowThreads();
47230 (arg1)->FitInside(arg2);
47231 wxPyEndAllowThreads(__tstate);
47232 if (PyErr_Occurred()) SWIG_fail;
47233 }
47234 resultobj = SWIG_Py_Void();
47235 return resultobj;
47236 fail:
47237 return NULL;
47238 }
47239
47240
47241 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47242 PyObject *resultobj = 0;
47243 wxSizer *arg1 = (wxSizer *) 0 ;
47244 wxWindow *arg2 = (wxWindow *) 0 ;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 void *argp2 = 0 ;
47248 int res2 = 0 ;
47249 PyObject * obj0 = 0 ;
47250 PyObject * obj1 = 0 ;
47251 char * kwnames[] = {
47252 (char *) "self",(char *) "window", NULL
47253 };
47254
47255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47257 if (!SWIG_IsOK(res1)) {
47258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47259 }
47260 arg1 = reinterpret_cast< wxSizer * >(argp1);
47261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47262 if (!SWIG_IsOK(res2)) {
47263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47264 }
47265 arg2 = reinterpret_cast< wxWindow * >(argp2);
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 (arg1)->SetSizeHints(arg2);
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_Py_Void();
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47280 PyObject *resultobj = 0;
47281 wxSizer *arg1 = (wxSizer *) 0 ;
47282 wxWindow *arg2 = (wxWindow *) 0 ;
47283 void *argp1 = 0 ;
47284 int res1 = 0 ;
47285 void *argp2 = 0 ;
47286 int res2 = 0 ;
47287 PyObject * obj0 = 0 ;
47288 PyObject * obj1 = 0 ;
47289 char * kwnames[] = {
47290 (char *) "self",(char *) "window", NULL
47291 };
47292
47293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47295 if (!SWIG_IsOK(res1)) {
47296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47297 }
47298 arg1 = reinterpret_cast< wxSizer * >(argp1);
47299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47300 if (!SWIG_IsOK(res2)) {
47301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47302 }
47303 arg2 = reinterpret_cast< wxWindow * >(argp2);
47304 {
47305 PyThreadState* __tstate = wxPyBeginAllowThreads();
47306 (arg1)->SetVirtualSizeHints(arg2);
47307 wxPyEndAllowThreads(__tstate);
47308 if (PyErr_Occurred()) SWIG_fail;
47309 }
47310 resultobj = SWIG_Py_Void();
47311 return resultobj;
47312 fail:
47313 return NULL;
47314 }
47315
47316
47317 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47318 PyObject *resultobj = 0;
47319 wxSizer *arg1 = (wxSizer *) 0 ;
47320 bool arg2 = (bool) false ;
47321 void *argp1 = 0 ;
47322 int res1 = 0 ;
47323 bool val2 ;
47324 int ecode2 = 0 ;
47325 PyObject * obj0 = 0 ;
47326 PyObject * obj1 = 0 ;
47327 char * kwnames[] = {
47328 (char *) "self",(char *) "deleteWindows", NULL
47329 };
47330
47331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47333 if (!SWIG_IsOK(res1)) {
47334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47335 }
47336 arg1 = reinterpret_cast< wxSizer * >(argp1);
47337 if (obj1) {
47338 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47339 if (!SWIG_IsOK(ecode2)) {
47340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47341 }
47342 arg2 = static_cast< bool >(val2);
47343 }
47344 {
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 (arg1)->Clear(arg2);
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 resultobj = SWIG_Py_Void();
47351 return resultobj;
47352 fail:
47353 return NULL;
47354 }
47355
47356
47357 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47358 PyObject *resultobj = 0;
47359 wxSizer *arg1 = (wxSizer *) 0 ;
47360 void *argp1 = 0 ;
47361 int res1 = 0 ;
47362 PyObject *swig_obj[1] ;
47363
47364 if (!args) SWIG_fail;
47365 swig_obj[0] = args;
47366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47367 if (!SWIG_IsOK(res1)) {
47368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47369 }
47370 arg1 = reinterpret_cast< wxSizer * >(argp1);
47371 {
47372 PyThreadState* __tstate = wxPyBeginAllowThreads();
47373 (arg1)->DeleteWindows();
47374 wxPyEndAllowThreads(__tstate);
47375 if (PyErr_Occurred()) SWIG_fail;
47376 }
47377 resultobj = SWIG_Py_Void();
47378 return resultobj;
47379 fail:
47380 return NULL;
47381 }
47382
47383
47384 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47385 PyObject *resultobj = 0;
47386 wxSizer *arg1 = (wxSizer *) 0 ;
47387 PyObject *result = 0 ;
47388 void *argp1 = 0 ;
47389 int res1 = 0 ;
47390 PyObject *swig_obj[1] ;
47391
47392 if (!args) SWIG_fail;
47393 swig_obj[0] = args;
47394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47395 if (!SWIG_IsOK(res1)) {
47396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47397 }
47398 arg1 = reinterpret_cast< wxSizer * >(argp1);
47399 {
47400 PyThreadState* __tstate = wxPyBeginAllowThreads();
47401 result = (PyObject *)wxSizer_GetChildren(arg1);
47402 wxPyEndAllowThreads(__tstate);
47403 if (PyErr_Occurred()) SWIG_fail;
47404 }
47405 resultobj = result;
47406 return resultobj;
47407 fail:
47408 return NULL;
47409 }
47410
47411
47412 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47413 PyObject *resultobj = 0;
47414 wxSizer *arg1 = (wxSizer *) 0 ;
47415 PyObject *arg2 = (PyObject *) 0 ;
47416 bool arg3 = (bool) true ;
47417 bool arg4 = (bool) false ;
47418 bool result;
47419 void *argp1 = 0 ;
47420 int res1 = 0 ;
47421 bool val3 ;
47422 int ecode3 = 0 ;
47423 bool val4 ;
47424 int ecode4 = 0 ;
47425 PyObject * obj0 = 0 ;
47426 PyObject * obj1 = 0 ;
47427 PyObject * obj2 = 0 ;
47428 PyObject * obj3 = 0 ;
47429 char * kwnames[] = {
47430 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47431 };
47432
47433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47437 }
47438 arg1 = reinterpret_cast< wxSizer * >(argp1);
47439 arg2 = obj1;
47440 if (obj2) {
47441 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47442 if (!SWIG_IsOK(ecode3)) {
47443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47444 }
47445 arg3 = static_cast< bool >(val3);
47446 }
47447 if (obj3) {
47448 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47449 if (!SWIG_IsOK(ecode4)) {
47450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47451 }
47452 arg4 = static_cast< bool >(val4);
47453 }
47454 {
47455 PyThreadState* __tstate = wxPyBeginAllowThreads();
47456 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47457 wxPyEndAllowThreads(__tstate);
47458 if (PyErr_Occurred()) SWIG_fail;
47459 }
47460 {
47461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47462 }
47463 return resultobj;
47464 fail:
47465 return NULL;
47466 }
47467
47468
47469 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47470 PyObject *resultobj = 0;
47471 wxSizer *arg1 = (wxSizer *) 0 ;
47472 PyObject *arg2 = (PyObject *) 0 ;
47473 bool result;
47474 void *argp1 = 0 ;
47475 int res1 = 0 ;
47476 PyObject * obj0 = 0 ;
47477 PyObject * obj1 = 0 ;
47478 char * kwnames[] = {
47479 (char *) "self",(char *) "item", NULL
47480 };
47481
47482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47484 if (!SWIG_IsOK(res1)) {
47485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47486 }
47487 arg1 = reinterpret_cast< wxSizer * >(argp1);
47488 arg2 = obj1;
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 result = (bool)wxSizer_IsShown(arg1,arg2);
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 {
47496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47497 }
47498 return resultobj;
47499 fail:
47500 return NULL;
47501 }
47502
47503
47504 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47505 PyObject *resultobj = 0;
47506 wxSizer *arg1 = (wxSizer *) 0 ;
47507 bool arg2 ;
47508 void *argp1 = 0 ;
47509 int res1 = 0 ;
47510 bool val2 ;
47511 int ecode2 = 0 ;
47512 PyObject * obj0 = 0 ;
47513 PyObject * obj1 = 0 ;
47514 char * kwnames[] = {
47515 (char *) "self",(char *) "show", NULL
47516 };
47517
47518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47520 if (!SWIG_IsOK(res1)) {
47521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47522 }
47523 arg1 = reinterpret_cast< wxSizer * >(argp1);
47524 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47525 if (!SWIG_IsOK(ecode2)) {
47526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47527 }
47528 arg2 = static_cast< bool >(val2);
47529 {
47530 PyThreadState* __tstate = wxPyBeginAllowThreads();
47531 (arg1)->ShowItems(arg2);
47532 wxPyEndAllowThreads(__tstate);
47533 if (PyErr_Occurred()) SWIG_fail;
47534 }
47535 resultobj = SWIG_Py_Void();
47536 return resultobj;
47537 fail:
47538 return NULL;
47539 }
47540
47541
47542 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47543 PyObject *obj;
47544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47545 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47546 return SWIG_Py_Void();
47547 }
47548
47549 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47550 PyObject *resultobj = 0;
47551 wxPySizer *result = 0 ;
47552
47553 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47554 {
47555 PyThreadState* __tstate = wxPyBeginAllowThreads();
47556 result = (wxPySizer *)new wxPySizer();
47557 wxPyEndAllowThreads(__tstate);
47558 if (PyErr_Occurred()) SWIG_fail;
47559 }
47560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47561 return resultobj;
47562 fail:
47563 return NULL;
47564 }
47565
47566
47567 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47568 PyObject *resultobj = 0;
47569 wxPySizer *arg1 = (wxPySizer *) 0 ;
47570 PyObject *arg2 = (PyObject *) 0 ;
47571 PyObject *arg3 = (PyObject *) 0 ;
47572 void *argp1 = 0 ;
47573 int res1 = 0 ;
47574 PyObject * obj0 = 0 ;
47575 PyObject * obj1 = 0 ;
47576 PyObject * obj2 = 0 ;
47577 char * kwnames[] = {
47578 (char *) "self",(char *) "self",(char *) "_class", NULL
47579 };
47580
47581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47585 }
47586 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47587 arg2 = obj1;
47588 arg3 = obj2;
47589 {
47590 PyThreadState* __tstate = wxPyBeginAllowThreads();
47591 (arg1)->_setCallbackInfo(arg2,arg3);
47592 wxPyEndAllowThreads(__tstate);
47593 if (PyErr_Occurred()) SWIG_fail;
47594 }
47595 resultobj = SWIG_Py_Void();
47596 return resultobj;
47597 fail:
47598 return NULL;
47599 }
47600
47601
47602 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47603 PyObject *obj;
47604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47605 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47606 return SWIG_Py_Void();
47607 }
47608
47609 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47610 return SWIG_Python_InitShadowInstance(args);
47611 }
47612
47613 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47614 PyObject *resultobj = 0;
47615 int arg1 = (int) wxHORIZONTAL ;
47616 wxBoxSizer *result = 0 ;
47617 int val1 ;
47618 int ecode1 = 0 ;
47619 PyObject * obj0 = 0 ;
47620 char * kwnames[] = {
47621 (char *) "orient", NULL
47622 };
47623
47624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47625 if (obj0) {
47626 ecode1 = SWIG_AsVal_int(obj0, &val1);
47627 if (!SWIG_IsOK(ecode1)) {
47628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47629 }
47630 arg1 = static_cast< int >(val1);
47631 }
47632 {
47633 PyThreadState* __tstate = wxPyBeginAllowThreads();
47634 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47635 wxPyEndAllowThreads(__tstate);
47636 if (PyErr_Occurred()) SWIG_fail;
47637 }
47638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47639 return resultobj;
47640 fail:
47641 return NULL;
47642 }
47643
47644
47645 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47646 PyObject *resultobj = 0;
47647 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47648 int result;
47649 void *argp1 = 0 ;
47650 int res1 = 0 ;
47651 PyObject *swig_obj[1] ;
47652
47653 if (!args) SWIG_fail;
47654 swig_obj[0] = args;
47655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47656 if (!SWIG_IsOK(res1)) {
47657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47658 }
47659 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47660 {
47661 PyThreadState* __tstate = wxPyBeginAllowThreads();
47662 result = (int)(arg1)->GetOrientation();
47663 wxPyEndAllowThreads(__tstate);
47664 if (PyErr_Occurred()) SWIG_fail;
47665 }
47666 resultobj = SWIG_From_int(static_cast< int >(result));
47667 return resultobj;
47668 fail:
47669 return NULL;
47670 }
47671
47672
47673 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47674 PyObject *resultobj = 0;
47675 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47676 int arg2 ;
47677 void *argp1 = 0 ;
47678 int res1 = 0 ;
47679 int val2 ;
47680 int ecode2 = 0 ;
47681 PyObject * obj0 = 0 ;
47682 PyObject * obj1 = 0 ;
47683 char * kwnames[] = {
47684 (char *) "self",(char *) "orient", NULL
47685 };
47686
47687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47689 if (!SWIG_IsOK(res1)) {
47690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47691 }
47692 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47693 ecode2 = SWIG_AsVal_int(obj1, &val2);
47694 if (!SWIG_IsOK(ecode2)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47696 }
47697 arg2 = static_cast< int >(val2);
47698 {
47699 PyThreadState* __tstate = wxPyBeginAllowThreads();
47700 (arg1)->SetOrientation(arg2);
47701 wxPyEndAllowThreads(__tstate);
47702 if (PyErr_Occurred()) SWIG_fail;
47703 }
47704 resultobj = SWIG_Py_Void();
47705 return resultobj;
47706 fail:
47707 return NULL;
47708 }
47709
47710
47711 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47712 PyObject *obj;
47713 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47714 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47715 return SWIG_Py_Void();
47716 }
47717
47718 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47719 return SWIG_Python_InitShadowInstance(args);
47720 }
47721
47722 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47723 PyObject *resultobj = 0;
47724 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47725 int arg2 = (int) wxHORIZONTAL ;
47726 wxStaticBoxSizer *result = 0 ;
47727 void *argp1 = 0 ;
47728 int res1 = 0 ;
47729 int val2 ;
47730 int ecode2 = 0 ;
47731 PyObject * obj0 = 0 ;
47732 PyObject * obj1 = 0 ;
47733 char * kwnames[] = {
47734 (char *) "box",(char *) "orient", NULL
47735 };
47736
47737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47739 if (!SWIG_IsOK(res1)) {
47740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47741 }
47742 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47743 if (obj1) {
47744 ecode2 = SWIG_AsVal_int(obj1, &val2);
47745 if (!SWIG_IsOK(ecode2)) {
47746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47747 }
47748 arg2 = static_cast< int >(val2);
47749 }
47750 {
47751 PyThreadState* __tstate = wxPyBeginAllowThreads();
47752 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47753 wxPyEndAllowThreads(__tstate);
47754 if (PyErr_Occurred()) SWIG_fail;
47755 }
47756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47757 return resultobj;
47758 fail:
47759 return NULL;
47760 }
47761
47762
47763 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47764 PyObject *resultobj = 0;
47765 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47766 wxStaticBox *result = 0 ;
47767 void *argp1 = 0 ;
47768 int res1 = 0 ;
47769 PyObject *swig_obj[1] ;
47770
47771 if (!args) SWIG_fail;
47772 swig_obj[0] = args;
47773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47774 if (!SWIG_IsOK(res1)) {
47775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47776 }
47777 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47778 {
47779 PyThreadState* __tstate = wxPyBeginAllowThreads();
47780 result = (wxStaticBox *)(arg1)->GetStaticBox();
47781 wxPyEndAllowThreads(__tstate);
47782 if (PyErr_Occurred()) SWIG_fail;
47783 }
47784 {
47785 resultobj = wxPyMake_wxObject(result, (bool)0);
47786 }
47787 return resultobj;
47788 fail:
47789 return NULL;
47790 }
47791
47792
47793 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47794 PyObject *obj;
47795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47796 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47797 return SWIG_Py_Void();
47798 }
47799
47800 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47801 return SWIG_Python_InitShadowInstance(args);
47802 }
47803
47804 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47805 PyObject *resultobj = 0;
47806 int arg1 = (int) 1 ;
47807 int arg2 = (int) 0 ;
47808 int arg3 = (int) 0 ;
47809 int arg4 = (int) 0 ;
47810 wxGridSizer *result = 0 ;
47811 int val1 ;
47812 int ecode1 = 0 ;
47813 int val2 ;
47814 int ecode2 = 0 ;
47815 int val3 ;
47816 int ecode3 = 0 ;
47817 int val4 ;
47818 int ecode4 = 0 ;
47819 PyObject * obj0 = 0 ;
47820 PyObject * obj1 = 0 ;
47821 PyObject * obj2 = 0 ;
47822 PyObject * obj3 = 0 ;
47823 char * kwnames[] = {
47824 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47825 };
47826
47827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47828 if (obj0) {
47829 ecode1 = SWIG_AsVal_int(obj0, &val1);
47830 if (!SWIG_IsOK(ecode1)) {
47831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47832 }
47833 arg1 = static_cast< int >(val1);
47834 }
47835 if (obj1) {
47836 ecode2 = SWIG_AsVal_int(obj1, &val2);
47837 if (!SWIG_IsOK(ecode2)) {
47838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47839 }
47840 arg2 = static_cast< int >(val2);
47841 }
47842 if (obj2) {
47843 ecode3 = SWIG_AsVal_int(obj2, &val3);
47844 if (!SWIG_IsOK(ecode3)) {
47845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47846 }
47847 arg3 = static_cast< int >(val3);
47848 }
47849 if (obj3) {
47850 ecode4 = SWIG_AsVal_int(obj3, &val4);
47851 if (!SWIG_IsOK(ecode4)) {
47852 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47853 }
47854 arg4 = static_cast< int >(val4);
47855 }
47856 {
47857 PyThreadState* __tstate = wxPyBeginAllowThreads();
47858 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47859 wxPyEndAllowThreads(__tstate);
47860 if (PyErr_Occurred()) SWIG_fail;
47861 }
47862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47863 return resultobj;
47864 fail:
47865 return NULL;
47866 }
47867
47868
47869 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47870 PyObject *resultobj = 0;
47871 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47872 int arg2 ;
47873 void *argp1 = 0 ;
47874 int res1 = 0 ;
47875 int val2 ;
47876 int ecode2 = 0 ;
47877 PyObject * obj0 = 0 ;
47878 PyObject * obj1 = 0 ;
47879 char * kwnames[] = {
47880 (char *) "self",(char *) "cols", NULL
47881 };
47882
47883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47885 if (!SWIG_IsOK(res1)) {
47886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47887 }
47888 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47889 ecode2 = SWIG_AsVal_int(obj1, &val2);
47890 if (!SWIG_IsOK(ecode2)) {
47891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47892 }
47893 arg2 = static_cast< int >(val2);
47894 {
47895 PyThreadState* __tstate = wxPyBeginAllowThreads();
47896 (arg1)->SetCols(arg2);
47897 wxPyEndAllowThreads(__tstate);
47898 if (PyErr_Occurred()) SWIG_fail;
47899 }
47900 resultobj = SWIG_Py_Void();
47901 return resultobj;
47902 fail:
47903 return NULL;
47904 }
47905
47906
47907 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47908 PyObject *resultobj = 0;
47909 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47910 int arg2 ;
47911 void *argp1 = 0 ;
47912 int res1 = 0 ;
47913 int val2 ;
47914 int ecode2 = 0 ;
47915 PyObject * obj0 = 0 ;
47916 PyObject * obj1 = 0 ;
47917 char * kwnames[] = {
47918 (char *) "self",(char *) "rows", NULL
47919 };
47920
47921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47923 if (!SWIG_IsOK(res1)) {
47924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47925 }
47926 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47927 ecode2 = SWIG_AsVal_int(obj1, &val2);
47928 if (!SWIG_IsOK(ecode2)) {
47929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47930 }
47931 arg2 = static_cast< int >(val2);
47932 {
47933 PyThreadState* __tstate = wxPyBeginAllowThreads();
47934 (arg1)->SetRows(arg2);
47935 wxPyEndAllowThreads(__tstate);
47936 if (PyErr_Occurred()) SWIG_fail;
47937 }
47938 resultobj = SWIG_Py_Void();
47939 return resultobj;
47940 fail:
47941 return NULL;
47942 }
47943
47944
47945 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47946 PyObject *resultobj = 0;
47947 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47948 int arg2 ;
47949 void *argp1 = 0 ;
47950 int res1 = 0 ;
47951 int val2 ;
47952 int ecode2 = 0 ;
47953 PyObject * obj0 = 0 ;
47954 PyObject * obj1 = 0 ;
47955 char * kwnames[] = {
47956 (char *) "self",(char *) "gap", NULL
47957 };
47958
47959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47961 if (!SWIG_IsOK(res1)) {
47962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47963 }
47964 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47965 ecode2 = SWIG_AsVal_int(obj1, &val2);
47966 if (!SWIG_IsOK(ecode2)) {
47967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47968 }
47969 arg2 = static_cast< int >(val2);
47970 {
47971 PyThreadState* __tstate = wxPyBeginAllowThreads();
47972 (arg1)->SetVGap(arg2);
47973 wxPyEndAllowThreads(__tstate);
47974 if (PyErr_Occurred()) SWIG_fail;
47975 }
47976 resultobj = SWIG_Py_Void();
47977 return resultobj;
47978 fail:
47979 return NULL;
47980 }
47981
47982
47983 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47984 PyObject *resultobj = 0;
47985 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47986 int arg2 ;
47987 void *argp1 = 0 ;
47988 int res1 = 0 ;
47989 int val2 ;
47990 int ecode2 = 0 ;
47991 PyObject * obj0 = 0 ;
47992 PyObject * obj1 = 0 ;
47993 char * kwnames[] = {
47994 (char *) "self",(char *) "gap", NULL
47995 };
47996
47997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47999 if (!SWIG_IsOK(res1)) {
48000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48001 }
48002 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48003 ecode2 = SWIG_AsVal_int(obj1, &val2);
48004 if (!SWIG_IsOK(ecode2)) {
48005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48006 }
48007 arg2 = static_cast< int >(val2);
48008 {
48009 PyThreadState* __tstate = wxPyBeginAllowThreads();
48010 (arg1)->SetHGap(arg2);
48011 wxPyEndAllowThreads(__tstate);
48012 if (PyErr_Occurred()) SWIG_fail;
48013 }
48014 resultobj = SWIG_Py_Void();
48015 return resultobj;
48016 fail:
48017 return NULL;
48018 }
48019
48020
48021 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48022 PyObject *resultobj = 0;
48023 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48024 int result;
48025 void *argp1 = 0 ;
48026 int res1 = 0 ;
48027 PyObject *swig_obj[1] ;
48028
48029 if (!args) SWIG_fail;
48030 swig_obj[0] = args;
48031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48032 if (!SWIG_IsOK(res1)) {
48033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48034 }
48035 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48036 {
48037 PyThreadState* __tstate = wxPyBeginAllowThreads();
48038 result = (int)(arg1)->GetCols();
48039 wxPyEndAllowThreads(__tstate);
48040 if (PyErr_Occurred()) SWIG_fail;
48041 }
48042 resultobj = SWIG_From_int(static_cast< int >(result));
48043 return resultobj;
48044 fail:
48045 return NULL;
48046 }
48047
48048
48049 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48050 PyObject *resultobj = 0;
48051 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48052 int result;
48053 void *argp1 = 0 ;
48054 int res1 = 0 ;
48055 PyObject *swig_obj[1] ;
48056
48057 if (!args) SWIG_fail;
48058 swig_obj[0] = args;
48059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48060 if (!SWIG_IsOK(res1)) {
48061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48062 }
48063 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48064 {
48065 PyThreadState* __tstate = wxPyBeginAllowThreads();
48066 result = (int)(arg1)->GetRows();
48067 wxPyEndAllowThreads(__tstate);
48068 if (PyErr_Occurred()) SWIG_fail;
48069 }
48070 resultobj = SWIG_From_int(static_cast< int >(result));
48071 return resultobj;
48072 fail:
48073 return NULL;
48074 }
48075
48076
48077 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48078 PyObject *resultobj = 0;
48079 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48080 int result;
48081 void *argp1 = 0 ;
48082 int res1 = 0 ;
48083 PyObject *swig_obj[1] ;
48084
48085 if (!args) SWIG_fail;
48086 swig_obj[0] = args;
48087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48088 if (!SWIG_IsOK(res1)) {
48089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48090 }
48091 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48092 {
48093 PyThreadState* __tstate = wxPyBeginAllowThreads();
48094 result = (int)(arg1)->GetVGap();
48095 wxPyEndAllowThreads(__tstate);
48096 if (PyErr_Occurred()) SWIG_fail;
48097 }
48098 resultobj = SWIG_From_int(static_cast< int >(result));
48099 return resultobj;
48100 fail:
48101 return NULL;
48102 }
48103
48104
48105 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48106 PyObject *resultobj = 0;
48107 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48108 int result;
48109 void *argp1 = 0 ;
48110 int res1 = 0 ;
48111 PyObject *swig_obj[1] ;
48112
48113 if (!args) SWIG_fail;
48114 swig_obj[0] = args;
48115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48116 if (!SWIG_IsOK(res1)) {
48117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48118 }
48119 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 result = (int)(arg1)->GetHGap();
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 resultobj = SWIG_From_int(static_cast< int >(result));
48127 return resultobj;
48128 fail:
48129 return NULL;
48130 }
48131
48132
48133 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48134 PyObject *obj;
48135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48136 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48137 return SWIG_Py_Void();
48138 }
48139
48140 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48141 return SWIG_Python_InitShadowInstance(args);
48142 }
48143
48144 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48145 PyObject *resultobj = 0;
48146 int arg1 = (int) 1 ;
48147 int arg2 = (int) 0 ;
48148 int arg3 = (int) 0 ;
48149 int arg4 = (int) 0 ;
48150 wxFlexGridSizer *result = 0 ;
48151 int val1 ;
48152 int ecode1 = 0 ;
48153 int val2 ;
48154 int ecode2 = 0 ;
48155 int val3 ;
48156 int ecode3 = 0 ;
48157 int val4 ;
48158 int ecode4 = 0 ;
48159 PyObject * obj0 = 0 ;
48160 PyObject * obj1 = 0 ;
48161 PyObject * obj2 = 0 ;
48162 PyObject * obj3 = 0 ;
48163 char * kwnames[] = {
48164 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48165 };
48166
48167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48168 if (obj0) {
48169 ecode1 = SWIG_AsVal_int(obj0, &val1);
48170 if (!SWIG_IsOK(ecode1)) {
48171 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48172 }
48173 arg1 = static_cast< int >(val1);
48174 }
48175 if (obj1) {
48176 ecode2 = SWIG_AsVal_int(obj1, &val2);
48177 if (!SWIG_IsOK(ecode2)) {
48178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48179 }
48180 arg2 = static_cast< int >(val2);
48181 }
48182 if (obj2) {
48183 ecode3 = SWIG_AsVal_int(obj2, &val3);
48184 if (!SWIG_IsOK(ecode3)) {
48185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48186 }
48187 arg3 = static_cast< int >(val3);
48188 }
48189 if (obj3) {
48190 ecode4 = SWIG_AsVal_int(obj3, &val4);
48191 if (!SWIG_IsOK(ecode4)) {
48192 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48193 }
48194 arg4 = static_cast< int >(val4);
48195 }
48196 {
48197 PyThreadState* __tstate = wxPyBeginAllowThreads();
48198 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48199 wxPyEndAllowThreads(__tstate);
48200 if (PyErr_Occurred()) SWIG_fail;
48201 }
48202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48203 return resultobj;
48204 fail:
48205 return NULL;
48206 }
48207
48208
48209 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48210 PyObject *resultobj = 0;
48211 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48212 size_t arg2 ;
48213 int arg3 = (int) 0 ;
48214 void *argp1 = 0 ;
48215 int res1 = 0 ;
48216 size_t val2 ;
48217 int ecode2 = 0 ;
48218 int val3 ;
48219 int ecode3 = 0 ;
48220 PyObject * obj0 = 0 ;
48221 PyObject * obj1 = 0 ;
48222 PyObject * obj2 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48233 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48234 if (!SWIG_IsOK(ecode2)) {
48235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48236 }
48237 arg2 = static_cast< size_t >(val2);
48238 if (obj2) {
48239 ecode3 = SWIG_AsVal_int(obj2, &val3);
48240 if (!SWIG_IsOK(ecode3)) {
48241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48242 }
48243 arg3 = static_cast< int >(val3);
48244 }
48245 {
48246 PyThreadState* __tstate = wxPyBeginAllowThreads();
48247 (arg1)->AddGrowableRow(arg2,arg3);
48248 wxPyEndAllowThreads(__tstate);
48249 if (PyErr_Occurred()) SWIG_fail;
48250 }
48251 resultobj = SWIG_Py_Void();
48252 return resultobj;
48253 fail:
48254 return NULL;
48255 }
48256
48257
48258 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48259 PyObject *resultobj = 0;
48260 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48261 size_t arg2 ;
48262 void *argp1 = 0 ;
48263 int res1 = 0 ;
48264 size_t val2 ;
48265 int ecode2 = 0 ;
48266 PyObject * obj0 = 0 ;
48267 PyObject * obj1 = 0 ;
48268 char * kwnames[] = {
48269 (char *) "self",(char *) "idx", NULL
48270 };
48271
48272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48274 if (!SWIG_IsOK(res1)) {
48275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48276 }
48277 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48278 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48279 if (!SWIG_IsOK(ecode2)) {
48280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48281 }
48282 arg2 = static_cast< size_t >(val2);
48283 {
48284 PyThreadState* __tstate = wxPyBeginAllowThreads();
48285 (arg1)->RemoveGrowableRow(arg2);
48286 wxPyEndAllowThreads(__tstate);
48287 if (PyErr_Occurred()) SWIG_fail;
48288 }
48289 resultobj = SWIG_Py_Void();
48290 return resultobj;
48291 fail:
48292 return NULL;
48293 }
48294
48295
48296 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48297 PyObject *resultobj = 0;
48298 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48299 size_t arg2 ;
48300 int arg3 = (int) 0 ;
48301 void *argp1 = 0 ;
48302 int res1 = 0 ;
48303 size_t val2 ;
48304 int ecode2 = 0 ;
48305 int val3 ;
48306 int ecode3 = 0 ;
48307 PyObject * obj0 = 0 ;
48308 PyObject * obj1 = 0 ;
48309 PyObject * obj2 = 0 ;
48310 char * kwnames[] = {
48311 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48312 };
48313
48314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48316 if (!SWIG_IsOK(res1)) {
48317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48318 }
48319 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48320 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48321 if (!SWIG_IsOK(ecode2)) {
48322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48323 }
48324 arg2 = static_cast< size_t >(val2);
48325 if (obj2) {
48326 ecode3 = SWIG_AsVal_int(obj2, &val3);
48327 if (!SWIG_IsOK(ecode3)) {
48328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48329 }
48330 arg3 = static_cast< int >(val3);
48331 }
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 (arg1)->AddGrowableCol(arg2,arg3);
48335 wxPyEndAllowThreads(__tstate);
48336 if (PyErr_Occurred()) SWIG_fail;
48337 }
48338 resultobj = SWIG_Py_Void();
48339 return resultobj;
48340 fail:
48341 return NULL;
48342 }
48343
48344
48345 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48346 PyObject *resultobj = 0;
48347 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48348 size_t arg2 ;
48349 void *argp1 = 0 ;
48350 int res1 = 0 ;
48351 size_t val2 ;
48352 int ecode2 = 0 ;
48353 PyObject * obj0 = 0 ;
48354 PyObject * obj1 = 0 ;
48355 char * kwnames[] = {
48356 (char *) "self",(char *) "idx", NULL
48357 };
48358
48359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48361 if (!SWIG_IsOK(res1)) {
48362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48363 }
48364 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48365 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48366 if (!SWIG_IsOK(ecode2)) {
48367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48368 }
48369 arg2 = static_cast< size_t >(val2);
48370 {
48371 PyThreadState* __tstate = wxPyBeginAllowThreads();
48372 (arg1)->RemoveGrowableCol(arg2);
48373 wxPyEndAllowThreads(__tstate);
48374 if (PyErr_Occurred()) SWIG_fail;
48375 }
48376 resultobj = SWIG_Py_Void();
48377 return resultobj;
48378 fail:
48379 return NULL;
48380 }
48381
48382
48383 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48384 PyObject *resultobj = 0;
48385 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48386 int arg2 ;
48387 void *argp1 = 0 ;
48388 int res1 = 0 ;
48389 int val2 ;
48390 int ecode2 = 0 ;
48391 PyObject * obj0 = 0 ;
48392 PyObject * obj1 = 0 ;
48393 char * kwnames[] = {
48394 (char *) "self",(char *) "direction", NULL
48395 };
48396
48397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48399 if (!SWIG_IsOK(res1)) {
48400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48401 }
48402 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48403 ecode2 = SWIG_AsVal_int(obj1, &val2);
48404 if (!SWIG_IsOK(ecode2)) {
48405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48406 }
48407 arg2 = static_cast< int >(val2);
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 (arg1)->SetFlexibleDirection(arg2);
48411 wxPyEndAllowThreads(__tstate);
48412 if (PyErr_Occurred()) SWIG_fail;
48413 }
48414 resultobj = SWIG_Py_Void();
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48422 PyObject *resultobj = 0;
48423 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48424 int result;
48425 void *argp1 = 0 ;
48426 int res1 = 0 ;
48427 PyObject *swig_obj[1] ;
48428
48429 if (!args) SWIG_fail;
48430 swig_obj[0] = args;
48431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48432 if (!SWIG_IsOK(res1)) {
48433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48434 }
48435 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 result = (int)(arg1)->GetFlexibleDirection();
48439 wxPyEndAllowThreads(__tstate);
48440 if (PyErr_Occurred()) SWIG_fail;
48441 }
48442 resultobj = SWIG_From_int(static_cast< int >(result));
48443 return resultobj;
48444 fail:
48445 return NULL;
48446 }
48447
48448
48449 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48450 PyObject *resultobj = 0;
48451 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48452 wxFlexSizerGrowMode arg2 ;
48453 void *argp1 = 0 ;
48454 int res1 = 0 ;
48455 int val2 ;
48456 int ecode2 = 0 ;
48457 PyObject * obj0 = 0 ;
48458 PyObject * obj1 = 0 ;
48459 char * kwnames[] = {
48460 (char *) "self",(char *) "mode", NULL
48461 };
48462
48463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48465 if (!SWIG_IsOK(res1)) {
48466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48467 }
48468 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48469 ecode2 = SWIG_AsVal_int(obj1, &val2);
48470 if (!SWIG_IsOK(ecode2)) {
48471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48472 }
48473 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48474 {
48475 PyThreadState* __tstate = wxPyBeginAllowThreads();
48476 (arg1)->SetNonFlexibleGrowMode(arg2);
48477 wxPyEndAllowThreads(__tstate);
48478 if (PyErr_Occurred()) SWIG_fail;
48479 }
48480 resultobj = SWIG_Py_Void();
48481 return resultobj;
48482 fail:
48483 return NULL;
48484 }
48485
48486
48487 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48488 PyObject *resultobj = 0;
48489 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48490 wxFlexSizerGrowMode result;
48491 void *argp1 = 0 ;
48492 int res1 = 0 ;
48493 PyObject *swig_obj[1] ;
48494
48495 if (!args) SWIG_fail;
48496 swig_obj[0] = args;
48497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48498 if (!SWIG_IsOK(res1)) {
48499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48500 }
48501 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48502 {
48503 PyThreadState* __tstate = wxPyBeginAllowThreads();
48504 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48505 wxPyEndAllowThreads(__tstate);
48506 if (PyErr_Occurred()) SWIG_fail;
48507 }
48508 resultobj = SWIG_From_int(static_cast< int >(result));
48509 return resultobj;
48510 fail:
48511 return NULL;
48512 }
48513
48514
48515 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48516 PyObject *resultobj = 0;
48517 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48518 wxArrayInt *result = 0 ;
48519 void *argp1 = 0 ;
48520 int res1 = 0 ;
48521 PyObject *swig_obj[1] ;
48522
48523 if (!args) SWIG_fail;
48524 swig_obj[0] = args;
48525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48526 if (!SWIG_IsOK(res1)) {
48527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48528 }
48529 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48530 {
48531 PyThreadState* __tstate = wxPyBeginAllowThreads();
48532 {
48533 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48534 result = (wxArrayInt *) &_result_ref;
48535 }
48536 wxPyEndAllowThreads(__tstate);
48537 if (PyErr_Occurred()) SWIG_fail;
48538 }
48539 {
48540 resultobj = PyList_New(0);
48541 size_t idx;
48542 for (idx = 0; idx < result->GetCount(); idx += 1) {
48543 PyObject* val = PyInt_FromLong( result->Item(idx) );
48544 PyList_Append(resultobj, val);
48545 Py_DECREF(val);
48546 }
48547 }
48548 return resultobj;
48549 fail:
48550 return NULL;
48551 }
48552
48553
48554 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48555 PyObject *resultobj = 0;
48556 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48557 wxArrayInt *result = 0 ;
48558 void *argp1 = 0 ;
48559 int res1 = 0 ;
48560 PyObject *swig_obj[1] ;
48561
48562 if (!args) SWIG_fail;
48563 swig_obj[0] = args;
48564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48565 if (!SWIG_IsOK(res1)) {
48566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48567 }
48568 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48569 {
48570 PyThreadState* __tstate = wxPyBeginAllowThreads();
48571 {
48572 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48573 result = (wxArrayInt *) &_result_ref;
48574 }
48575 wxPyEndAllowThreads(__tstate);
48576 if (PyErr_Occurred()) SWIG_fail;
48577 }
48578 {
48579 resultobj = PyList_New(0);
48580 size_t idx;
48581 for (idx = 0; idx < result->GetCount(); idx += 1) {
48582 PyObject* val = PyInt_FromLong( result->Item(idx) );
48583 PyList_Append(resultobj, val);
48584 Py_DECREF(val);
48585 }
48586 }
48587 return resultobj;
48588 fail:
48589 return NULL;
48590 }
48591
48592
48593 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48594 PyObject *obj;
48595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48596 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48597 return SWIG_Py_Void();
48598 }
48599
48600 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48601 return SWIG_Python_InitShadowInstance(args);
48602 }
48603
48604 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48605 PyObject *resultobj = 0;
48606 wxStdDialogButtonSizer *result = 0 ;
48607
48608 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48609 {
48610 PyThreadState* __tstate = wxPyBeginAllowThreads();
48611 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48612 wxPyEndAllowThreads(__tstate);
48613 if (PyErr_Occurred()) SWIG_fail;
48614 }
48615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48616 return resultobj;
48617 fail:
48618 return NULL;
48619 }
48620
48621
48622 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48623 PyObject *resultobj = 0;
48624 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48625 wxButton *arg2 = (wxButton *) 0 ;
48626 void *argp1 = 0 ;
48627 int res1 = 0 ;
48628 void *argp2 = 0 ;
48629 int res2 = 0 ;
48630 PyObject * obj0 = 0 ;
48631 PyObject * obj1 = 0 ;
48632 char * kwnames[] = {
48633 (char *) "self",(char *) "button", NULL
48634 };
48635
48636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48638 if (!SWIG_IsOK(res1)) {
48639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48640 }
48641 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48642 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48643 if (!SWIG_IsOK(res2)) {
48644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48645 }
48646 arg2 = reinterpret_cast< wxButton * >(argp2);
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 (arg1)->AddButton(arg2);
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_Py_Void();
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48661 PyObject *resultobj = 0;
48662 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48663 void *argp1 = 0 ;
48664 int res1 = 0 ;
48665 PyObject *swig_obj[1] ;
48666
48667 if (!args) SWIG_fail;
48668 swig_obj[0] = args;
48669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48670 if (!SWIG_IsOK(res1)) {
48671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48672 }
48673 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48674 {
48675 PyThreadState* __tstate = wxPyBeginAllowThreads();
48676 (arg1)->Realize();
48677 wxPyEndAllowThreads(__tstate);
48678 if (PyErr_Occurred()) SWIG_fail;
48679 }
48680 resultobj = SWIG_Py_Void();
48681 return resultobj;
48682 fail:
48683 return NULL;
48684 }
48685
48686
48687 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48688 PyObject *resultobj = 0;
48689 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48690 wxButton *arg2 = (wxButton *) 0 ;
48691 void *argp1 = 0 ;
48692 int res1 = 0 ;
48693 void *argp2 = 0 ;
48694 int res2 = 0 ;
48695 PyObject * obj0 = 0 ;
48696 PyObject * obj1 = 0 ;
48697 char * kwnames[] = {
48698 (char *) "self",(char *) "button", NULL
48699 };
48700
48701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48703 if (!SWIG_IsOK(res1)) {
48704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48705 }
48706 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48707 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48708 if (!SWIG_IsOK(res2)) {
48709 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48710 }
48711 arg2 = reinterpret_cast< wxButton * >(argp2);
48712 {
48713 PyThreadState* __tstate = wxPyBeginAllowThreads();
48714 (arg1)->SetAffirmativeButton(arg2);
48715 wxPyEndAllowThreads(__tstate);
48716 if (PyErr_Occurred()) SWIG_fail;
48717 }
48718 resultobj = SWIG_Py_Void();
48719 return resultobj;
48720 fail:
48721 return NULL;
48722 }
48723
48724
48725 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48726 PyObject *resultobj = 0;
48727 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48728 wxButton *arg2 = (wxButton *) 0 ;
48729 void *argp1 = 0 ;
48730 int res1 = 0 ;
48731 void *argp2 = 0 ;
48732 int res2 = 0 ;
48733 PyObject * obj0 = 0 ;
48734 PyObject * obj1 = 0 ;
48735 char * kwnames[] = {
48736 (char *) "self",(char *) "button", NULL
48737 };
48738
48739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48741 if (!SWIG_IsOK(res1)) {
48742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48743 }
48744 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48746 if (!SWIG_IsOK(res2)) {
48747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48748 }
48749 arg2 = reinterpret_cast< wxButton * >(argp2);
48750 {
48751 PyThreadState* __tstate = wxPyBeginAllowThreads();
48752 (arg1)->SetNegativeButton(arg2);
48753 wxPyEndAllowThreads(__tstate);
48754 if (PyErr_Occurred()) SWIG_fail;
48755 }
48756 resultobj = SWIG_Py_Void();
48757 return resultobj;
48758 fail:
48759 return NULL;
48760 }
48761
48762
48763 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48764 PyObject *resultobj = 0;
48765 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48766 wxButton *arg2 = (wxButton *) 0 ;
48767 void *argp1 = 0 ;
48768 int res1 = 0 ;
48769 void *argp2 = 0 ;
48770 int res2 = 0 ;
48771 PyObject * obj0 = 0 ;
48772 PyObject * obj1 = 0 ;
48773 char * kwnames[] = {
48774 (char *) "self",(char *) "button", NULL
48775 };
48776
48777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48779 if (!SWIG_IsOK(res1)) {
48780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48781 }
48782 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48784 if (!SWIG_IsOK(res2)) {
48785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48786 }
48787 arg2 = reinterpret_cast< wxButton * >(argp2);
48788 {
48789 PyThreadState* __tstate = wxPyBeginAllowThreads();
48790 (arg1)->SetCancelButton(arg2);
48791 wxPyEndAllowThreads(__tstate);
48792 if (PyErr_Occurred()) SWIG_fail;
48793 }
48794 resultobj = SWIG_Py_Void();
48795 return resultobj;
48796 fail:
48797 return NULL;
48798 }
48799
48800
48801 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48802 PyObject *resultobj = 0;
48803 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48804 wxButton *result = 0 ;
48805 void *argp1 = 0 ;
48806 int res1 = 0 ;
48807 PyObject *swig_obj[1] ;
48808
48809 if (!args) SWIG_fail;
48810 swig_obj[0] = args;
48811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48812 if (!SWIG_IsOK(res1)) {
48813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48814 }
48815 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48816 {
48817 PyThreadState* __tstate = wxPyBeginAllowThreads();
48818 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48819 wxPyEndAllowThreads(__tstate);
48820 if (PyErr_Occurred()) SWIG_fail;
48821 }
48822 {
48823 resultobj = wxPyMake_wxObject(result, (bool)0);
48824 }
48825 return resultobj;
48826 fail:
48827 return NULL;
48828 }
48829
48830
48831 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48832 PyObject *resultobj = 0;
48833 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48834 wxButton *result = 0 ;
48835 void *argp1 = 0 ;
48836 int res1 = 0 ;
48837 PyObject *swig_obj[1] ;
48838
48839 if (!args) SWIG_fail;
48840 swig_obj[0] = args;
48841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48844 }
48845 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48846 {
48847 PyThreadState* __tstate = wxPyBeginAllowThreads();
48848 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48849 wxPyEndAllowThreads(__tstate);
48850 if (PyErr_Occurred()) SWIG_fail;
48851 }
48852 {
48853 resultobj = wxPyMake_wxObject(result, (bool)0);
48854 }
48855 return resultobj;
48856 fail:
48857 return NULL;
48858 }
48859
48860
48861 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48862 PyObject *resultobj = 0;
48863 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48864 wxButton *result = 0 ;
48865 void *argp1 = 0 ;
48866 int res1 = 0 ;
48867 PyObject *swig_obj[1] ;
48868
48869 if (!args) SWIG_fail;
48870 swig_obj[0] = args;
48871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48872 if (!SWIG_IsOK(res1)) {
48873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48874 }
48875 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 {
48883 resultobj = wxPyMake_wxObject(result, (bool)0);
48884 }
48885 return resultobj;
48886 fail:
48887 return NULL;
48888 }
48889
48890
48891 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48892 PyObject *resultobj = 0;
48893 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48894 wxButton *result = 0 ;
48895 void *argp1 = 0 ;
48896 int res1 = 0 ;
48897 PyObject *swig_obj[1] ;
48898
48899 if (!args) SWIG_fail;
48900 swig_obj[0] = args;
48901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48902 if (!SWIG_IsOK(res1)) {
48903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48904 }
48905 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48906 {
48907 PyThreadState* __tstate = wxPyBeginAllowThreads();
48908 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48909 wxPyEndAllowThreads(__tstate);
48910 if (PyErr_Occurred()) SWIG_fail;
48911 }
48912 {
48913 resultobj = wxPyMake_wxObject(result, (bool)0);
48914 }
48915 return resultobj;
48916 fail:
48917 return NULL;
48918 }
48919
48920
48921 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48922 PyObject *resultobj = 0;
48923 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48924 wxButton *result = 0 ;
48925 void *argp1 = 0 ;
48926 int res1 = 0 ;
48927 PyObject *swig_obj[1] ;
48928
48929 if (!args) SWIG_fail;
48930 swig_obj[0] = args;
48931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48932 if (!SWIG_IsOK(res1)) {
48933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48934 }
48935 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48936 {
48937 PyThreadState* __tstate = wxPyBeginAllowThreads();
48938 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48939 wxPyEndAllowThreads(__tstate);
48940 if (PyErr_Occurred()) SWIG_fail;
48941 }
48942 {
48943 resultobj = wxPyMake_wxObject(result, (bool)0);
48944 }
48945 return resultobj;
48946 fail:
48947 return NULL;
48948 }
48949
48950
48951 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48952 PyObject *obj;
48953 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48954 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48955 return SWIG_Py_Void();
48956 }
48957
48958 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 return SWIG_Python_InitShadowInstance(args);
48960 }
48961
48962 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48963 PyObject *resultobj = 0;
48964 int arg1 = (int) 0 ;
48965 int arg2 = (int) 0 ;
48966 wxGBPosition *result = 0 ;
48967 int val1 ;
48968 int ecode1 = 0 ;
48969 int val2 ;
48970 int ecode2 = 0 ;
48971 PyObject * obj0 = 0 ;
48972 PyObject * obj1 = 0 ;
48973 char * kwnames[] = {
48974 (char *) "row",(char *) "col", NULL
48975 };
48976
48977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48978 if (obj0) {
48979 ecode1 = SWIG_AsVal_int(obj0, &val1);
48980 if (!SWIG_IsOK(ecode1)) {
48981 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48982 }
48983 arg1 = static_cast< int >(val1);
48984 }
48985 if (obj1) {
48986 ecode2 = SWIG_AsVal_int(obj1, &val2);
48987 if (!SWIG_IsOK(ecode2)) {
48988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48989 }
48990 arg2 = static_cast< int >(val2);
48991 }
48992 {
48993 PyThreadState* __tstate = wxPyBeginAllowThreads();
48994 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48995 wxPyEndAllowThreads(__tstate);
48996 if (PyErr_Occurred()) SWIG_fail;
48997 }
48998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48999 return resultobj;
49000 fail:
49001 return NULL;
49002 }
49003
49004
49005 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49006 PyObject *resultobj = 0;
49007 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49008 void *argp1 = 0 ;
49009 int res1 = 0 ;
49010 PyObject *swig_obj[1] ;
49011
49012 if (!args) SWIG_fail;
49013 swig_obj[0] = args;
49014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49015 if (!SWIG_IsOK(res1)) {
49016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49017 }
49018 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49019 {
49020 PyThreadState* __tstate = wxPyBeginAllowThreads();
49021 delete arg1;
49022
49023 wxPyEndAllowThreads(__tstate);
49024 if (PyErr_Occurred()) SWIG_fail;
49025 }
49026 resultobj = SWIG_Py_Void();
49027 return resultobj;
49028 fail:
49029 return NULL;
49030 }
49031
49032
49033 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49034 PyObject *resultobj = 0;
49035 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49036 int result;
49037 void *argp1 = 0 ;
49038 int res1 = 0 ;
49039 PyObject *swig_obj[1] ;
49040
49041 if (!args) SWIG_fail;
49042 swig_obj[0] = args;
49043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49044 if (!SWIG_IsOK(res1)) {
49045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49046 }
49047 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49048 {
49049 PyThreadState* __tstate = wxPyBeginAllowThreads();
49050 result = (int)((wxGBPosition const *)arg1)->GetRow();
49051 wxPyEndAllowThreads(__tstate);
49052 if (PyErr_Occurred()) SWIG_fail;
49053 }
49054 resultobj = SWIG_From_int(static_cast< int >(result));
49055 return resultobj;
49056 fail:
49057 return NULL;
49058 }
49059
49060
49061 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49062 PyObject *resultobj = 0;
49063 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49064 int result;
49065 void *argp1 = 0 ;
49066 int res1 = 0 ;
49067 PyObject *swig_obj[1] ;
49068
49069 if (!args) SWIG_fail;
49070 swig_obj[0] = args;
49071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49072 if (!SWIG_IsOK(res1)) {
49073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49074 }
49075 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49076 {
49077 PyThreadState* __tstate = wxPyBeginAllowThreads();
49078 result = (int)((wxGBPosition const *)arg1)->GetCol();
49079 wxPyEndAllowThreads(__tstate);
49080 if (PyErr_Occurred()) SWIG_fail;
49081 }
49082 resultobj = SWIG_From_int(static_cast< int >(result));
49083 return resultobj;
49084 fail:
49085 return NULL;
49086 }
49087
49088
49089 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49090 PyObject *resultobj = 0;
49091 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49092 int arg2 ;
49093 void *argp1 = 0 ;
49094 int res1 = 0 ;
49095 int val2 ;
49096 int ecode2 = 0 ;
49097 PyObject * obj0 = 0 ;
49098 PyObject * obj1 = 0 ;
49099 char * kwnames[] = {
49100 (char *) "self",(char *) "row", NULL
49101 };
49102
49103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49105 if (!SWIG_IsOK(res1)) {
49106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49107 }
49108 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49109 ecode2 = SWIG_AsVal_int(obj1, &val2);
49110 if (!SWIG_IsOK(ecode2)) {
49111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49112 }
49113 arg2 = static_cast< int >(val2);
49114 {
49115 PyThreadState* __tstate = wxPyBeginAllowThreads();
49116 (arg1)->SetRow(arg2);
49117 wxPyEndAllowThreads(__tstate);
49118 if (PyErr_Occurred()) SWIG_fail;
49119 }
49120 resultobj = SWIG_Py_Void();
49121 return resultobj;
49122 fail:
49123 return NULL;
49124 }
49125
49126
49127 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49128 PyObject *resultobj = 0;
49129 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49130 int arg2 ;
49131 void *argp1 = 0 ;
49132 int res1 = 0 ;
49133 int val2 ;
49134 int ecode2 = 0 ;
49135 PyObject * obj0 = 0 ;
49136 PyObject * obj1 = 0 ;
49137 char * kwnames[] = {
49138 (char *) "self",(char *) "col", NULL
49139 };
49140
49141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49143 if (!SWIG_IsOK(res1)) {
49144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49145 }
49146 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49147 ecode2 = SWIG_AsVal_int(obj1, &val2);
49148 if (!SWIG_IsOK(ecode2)) {
49149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49150 }
49151 arg2 = static_cast< int >(val2);
49152 {
49153 PyThreadState* __tstate = wxPyBeginAllowThreads();
49154 (arg1)->SetCol(arg2);
49155 wxPyEndAllowThreads(__tstate);
49156 if (PyErr_Occurred()) SWIG_fail;
49157 }
49158 resultobj = SWIG_Py_Void();
49159 return resultobj;
49160 fail:
49161 return NULL;
49162 }
49163
49164
49165 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49166 PyObject *resultobj = 0;
49167 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49168 PyObject *arg2 = (PyObject *) 0 ;
49169 bool result;
49170 void *argp1 = 0 ;
49171 int res1 = 0 ;
49172 PyObject * obj0 = 0 ;
49173 PyObject * obj1 = 0 ;
49174 char * kwnames[] = {
49175 (char *) "self",(char *) "other", NULL
49176 };
49177
49178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49180 if (!SWIG_IsOK(res1)) {
49181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49182 }
49183 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49184 arg2 = obj1;
49185 {
49186 result = (bool)wxGBPosition___eq__(arg1,arg2);
49187 if (PyErr_Occurred()) SWIG_fail;
49188 }
49189 {
49190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49191 }
49192 return resultobj;
49193 fail:
49194 return NULL;
49195 }
49196
49197
49198 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49199 PyObject *resultobj = 0;
49200 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49201 PyObject *arg2 = (PyObject *) 0 ;
49202 bool result;
49203 void *argp1 = 0 ;
49204 int res1 = 0 ;
49205 PyObject * obj0 = 0 ;
49206 PyObject * obj1 = 0 ;
49207 char * kwnames[] = {
49208 (char *) "self",(char *) "other", NULL
49209 };
49210
49211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49213 if (!SWIG_IsOK(res1)) {
49214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49215 }
49216 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49217 arg2 = obj1;
49218 {
49219 result = (bool)wxGBPosition___ne__(arg1,arg2);
49220 if (PyErr_Occurred()) SWIG_fail;
49221 }
49222 {
49223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49224 }
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49232 PyObject *resultobj = 0;
49233 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49234 int arg2 = (int) 0 ;
49235 int arg3 = (int) 0 ;
49236 void *argp1 = 0 ;
49237 int res1 = 0 ;
49238 int val2 ;
49239 int ecode2 = 0 ;
49240 int val3 ;
49241 int ecode3 = 0 ;
49242 PyObject * obj0 = 0 ;
49243 PyObject * obj1 = 0 ;
49244 PyObject * obj2 = 0 ;
49245 char * kwnames[] = {
49246 (char *) "self",(char *) "row",(char *) "col", NULL
49247 };
49248
49249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49251 if (!SWIG_IsOK(res1)) {
49252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49253 }
49254 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49255 if (obj1) {
49256 ecode2 = SWIG_AsVal_int(obj1, &val2);
49257 if (!SWIG_IsOK(ecode2)) {
49258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49259 }
49260 arg2 = static_cast< int >(val2);
49261 }
49262 if (obj2) {
49263 ecode3 = SWIG_AsVal_int(obj2, &val3);
49264 if (!SWIG_IsOK(ecode3)) {
49265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49266 }
49267 arg3 = static_cast< int >(val3);
49268 }
49269 {
49270 PyThreadState* __tstate = wxPyBeginAllowThreads();
49271 wxGBPosition_Set(arg1,arg2,arg3);
49272 wxPyEndAllowThreads(__tstate);
49273 if (PyErr_Occurred()) SWIG_fail;
49274 }
49275 resultobj = SWIG_Py_Void();
49276 return resultobj;
49277 fail:
49278 return NULL;
49279 }
49280
49281
49282 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49283 PyObject *resultobj = 0;
49284 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49285 PyObject *result = 0 ;
49286 void *argp1 = 0 ;
49287 int res1 = 0 ;
49288 PyObject *swig_obj[1] ;
49289
49290 if (!args) SWIG_fail;
49291 swig_obj[0] = args;
49292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49293 if (!SWIG_IsOK(res1)) {
49294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49295 }
49296 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49297 {
49298 PyThreadState* __tstate = wxPyBeginAllowThreads();
49299 result = (PyObject *)wxGBPosition_Get(arg1);
49300 wxPyEndAllowThreads(__tstate);
49301 if (PyErr_Occurred()) SWIG_fail;
49302 }
49303 resultobj = result;
49304 return resultobj;
49305 fail:
49306 return NULL;
49307 }
49308
49309
49310 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49311 PyObject *obj;
49312 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49313 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49314 return SWIG_Py_Void();
49315 }
49316
49317 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49318 return SWIG_Python_InitShadowInstance(args);
49319 }
49320
49321 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49322 PyObject *resultobj = 0;
49323 int arg1 = (int) 1 ;
49324 int arg2 = (int) 1 ;
49325 wxGBSpan *result = 0 ;
49326 int val1 ;
49327 int ecode1 = 0 ;
49328 int val2 ;
49329 int ecode2 = 0 ;
49330 PyObject * obj0 = 0 ;
49331 PyObject * obj1 = 0 ;
49332 char * kwnames[] = {
49333 (char *) "rowspan",(char *) "colspan", NULL
49334 };
49335
49336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49337 if (obj0) {
49338 ecode1 = SWIG_AsVal_int(obj0, &val1);
49339 if (!SWIG_IsOK(ecode1)) {
49340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49341 }
49342 arg1 = static_cast< int >(val1);
49343 }
49344 if (obj1) {
49345 ecode2 = SWIG_AsVal_int(obj1, &val2);
49346 if (!SWIG_IsOK(ecode2)) {
49347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49348 }
49349 arg2 = static_cast< int >(val2);
49350 }
49351 {
49352 PyThreadState* __tstate = wxPyBeginAllowThreads();
49353 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49354 wxPyEndAllowThreads(__tstate);
49355 if (PyErr_Occurred()) SWIG_fail;
49356 }
49357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49358 return resultobj;
49359 fail:
49360 return NULL;
49361 }
49362
49363
49364 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49365 PyObject *resultobj = 0;
49366 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49367 void *argp1 = 0 ;
49368 int res1 = 0 ;
49369 PyObject *swig_obj[1] ;
49370
49371 if (!args) SWIG_fail;
49372 swig_obj[0] = args;
49373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49374 if (!SWIG_IsOK(res1)) {
49375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49376 }
49377 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49378 {
49379 PyThreadState* __tstate = wxPyBeginAllowThreads();
49380 delete arg1;
49381
49382 wxPyEndAllowThreads(__tstate);
49383 if (PyErr_Occurred()) SWIG_fail;
49384 }
49385 resultobj = SWIG_Py_Void();
49386 return resultobj;
49387 fail:
49388 return NULL;
49389 }
49390
49391
49392 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49393 PyObject *resultobj = 0;
49394 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49395 int result;
49396 void *argp1 = 0 ;
49397 int res1 = 0 ;
49398 PyObject *swig_obj[1] ;
49399
49400 if (!args) SWIG_fail;
49401 swig_obj[0] = args;
49402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49405 }
49406 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49407 {
49408 PyThreadState* __tstate = wxPyBeginAllowThreads();
49409 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49410 wxPyEndAllowThreads(__tstate);
49411 if (PyErr_Occurred()) SWIG_fail;
49412 }
49413 resultobj = SWIG_From_int(static_cast< int >(result));
49414 return resultobj;
49415 fail:
49416 return NULL;
49417 }
49418
49419
49420 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49421 PyObject *resultobj = 0;
49422 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49423 int result;
49424 void *argp1 = 0 ;
49425 int res1 = 0 ;
49426 PyObject *swig_obj[1] ;
49427
49428 if (!args) SWIG_fail;
49429 swig_obj[0] = args;
49430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49431 if (!SWIG_IsOK(res1)) {
49432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49433 }
49434 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49435 {
49436 PyThreadState* __tstate = wxPyBeginAllowThreads();
49437 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49438 wxPyEndAllowThreads(__tstate);
49439 if (PyErr_Occurred()) SWIG_fail;
49440 }
49441 resultobj = SWIG_From_int(static_cast< int >(result));
49442 return resultobj;
49443 fail:
49444 return NULL;
49445 }
49446
49447
49448 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49449 PyObject *resultobj = 0;
49450 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49451 int arg2 ;
49452 void *argp1 = 0 ;
49453 int res1 = 0 ;
49454 int val2 ;
49455 int ecode2 = 0 ;
49456 PyObject * obj0 = 0 ;
49457 PyObject * obj1 = 0 ;
49458 char * kwnames[] = {
49459 (char *) "self",(char *) "rowspan", NULL
49460 };
49461
49462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49464 if (!SWIG_IsOK(res1)) {
49465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49466 }
49467 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49468 ecode2 = SWIG_AsVal_int(obj1, &val2);
49469 if (!SWIG_IsOK(ecode2)) {
49470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49471 }
49472 arg2 = static_cast< int >(val2);
49473 {
49474 PyThreadState* __tstate = wxPyBeginAllowThreads();
49475 (arg1)->SetRowspan(arg2);
49476 wxPyEndAllowThreads(__tstate);
49477 if (PyErr_Occurred()) SWIG_fail;
49478 }
49479 resultobj = SWIG_Py_Void();
49480 return resultobj;
49481 fail:
49482 return NULL;
49483 }
49484
49485
49486 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49487 PyObject *resultobj = 0;
49488 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49489 int arg2 ;
49490 void *argp1 = 0 ;
49491 int res1 = 0 ;
49492 int val2 ;
49493 int ecode2 = 0 ;
49494 PyObject * obj0 = 0 ;
49495 PyObject * obj1 = 0 ;
49496 char * kwnames[] = {
49497 (char *) "self",(char *) "colspan", NULL
49498 };
49499
49500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49502 if (!SWIG_IsOK(res1)) {
49503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49504 }
49505 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49506 ecode2 = SWIG_AsVal_int(obj1, &val2);
49507 if (!SWIG_IsOK(ecode2)) {
49508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49509 }
49510 arg2 = static_cast< int >(val2);
49511 {
49512 PyThreadState* __tstate = wxPyBeginAllowThreads();
49513 (arg1)->SetColspan(arg2);
49514 wxPyEndAllowThreads(__tstate);
49515 if (PyErr_Occurred()) SWIG_fail;
49516 }
49517 resultobj = SWIG_Py_Void();
49518 return resultobj;
49519 fail:
49520 return NULL;
49521 }
49522
49523
49524 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49525 PyObject *resultobj = 0;
49526 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49527 PyObject *arg2 = (PyObject *) 0 ;
49528 bool result;
49529 void *argp1 = 0 ;
49530 int res1 = 0 ;
49531 PyObject * obj0 = 0 ;
49532 PyObject * obj1 = 0 ;
49533 char * kwnames[] = {
49534 (char *) "self",(char *) "other", NULL
49535 };
49536
49537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49539 if (!SWIG_IsOK(res1)) {
49540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49541 }
49542 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49543 arg2 = obj1;
49544 {
49545 result = (bool)wxGBSpan___eq__(arg1,arg2);
49546 if (PyErr_Occurred()) SWIG_fail;
49547 }
49548 {
49549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49550 }
49551 return resultobj;
49552 fail:
49553 return NULL;
49554 }
49555
49556
49557 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49558 PyObject *resultobj = 0;
49559 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49560 PyObject *arg2 = (PyObject *) 0 ;
49561 bool result;
49562 void *argp1 = 0 ;
49563 int res1 = 0 ;
49564 PyObject * obj0 = 0 ;
49565 PyObject * obj1 = 0 ;
49566 char * kwnames[] = {
49567 (char *) "self",(char *) "other", NULL
49568 };
49569
49570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49572 if (!SWIG_IsOK(res1)) {
49573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49574 }
49575 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49576 arg2 = obj1;
49577 {
49578 result = (bool)wxGBSpan___ne__(arg1,arg2);
49579 if (PyErr_Occurred()) SWIG_fail;
49580 }
49581 {
49582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49583 }
49584 return resultobj;
49585 fail:
49586 return NULL;
49587 }
49588
49589
49590 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49591 PyObject *resultobj = 0;
49592 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49593 int arg2 = (int) 1 ;
49594 int arg3 = (int) 1 ;
49595 void *argp1 = 0 ;
49596 int res1 = 0 ;
49597 int val2 ;
49598 int ecode2 = 0 ;
49599 int val3 ;
49600 int ecode3 = 0 ;
49601 PyObject * obj0 = 0 ;
49602 PyObject * obj1 = 0 ;
49603 PyObject * obj2 = 0 ;
49604 char * kwnames[] = {
49605 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49606 };
49607
49608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49610 if (!SWIG_IsOK(res1)) {
49611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49612 }
49613 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49614 if (obj1) {
49615 ecode2 = SWIG_AsVal_int(obj1, &val2);
49616 if (!SWIG_IsOK(ecode2)) {
49617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49618 }
49619 arg2 = static_cast< int >(val2);
49620 }
49621 if (obj2) {
49622 ecode3 = SWIG_AsVal_int(obj2, &val3);
49623 if (!SWIG_IsOK(ecode3)) {
49624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49625 }
49626 arg3 = static_cast< int >(val3);
49627 }
49628 {
49629 PyThreadState* __tstate = wxPyBeginAllowThreads();
49630 wxGBSpan_Set(arg1,arg2,arg3);
49631 wxPyEndAllowThreads(__tstate);
49632 if (PyErr_Occurred()) SWIG_fail;
49633 }
49634 resultobj = SWIG_Py_Void();
49635 return resultobj;
49636 fail:
49637 return NULL;
49638 }
49639
49640
49641 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49642 PyObject *resultobj = 0;
49643 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49644 PyObject *result = 0 ;
49645 void *argp1 = 0 ;
49646 int res1 = 0 ;
49647 PyObject *swig_obj[1] ;
49648
49649 if (!args) SWIG_fail;
49650 swig_obj[0] = args;
49651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49652 if (!SWIG_IsOK(res1)) {
49653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49654 }
49655 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49656 {
49657 PyThreadState* __tstate = wxPyBeginAllowThreads();
49658 result = (PyObject *)wxGBSpan_Get(arg1);
49659 wxPyEndAllowThreads(__tstate);
49660 if (PyErr_Occurred()) SWIG_fail;
49661 }
49662 resultobj = result;
49663 return resultobj;
49664 fail:
49665 return NULL;
49666 }
49667
49668
49669 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49670 PyObject *obj;
49671 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49672 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49673 return SWIG_Py_Void();
49674 }
49675
49676 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49677 return SWIG_Python_InitShadowInstance(args);
49678 }
49679
49680 SWIGINTERN int DefaultSpan_set(PyObject *) {
49681 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49682 return 1;
49683 }
49684
49685
49686 SWIGINTERN PyObject *DefaultSpan_get(void) {
49687 PyObject *pyobj = 0;
49688
49689 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49690 return pyobj;
49691 }
49692
49693
49694 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49695 PyObject *resultobj = 0;
49696 wxGBSizerItem *result = 0 ;
49697
49698 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49699 {
49700 PyThreadState* __tstate = wxPyBeginAllowThreads();
49701 result = (wxGBSizerItem *)new wxGBSizerItem();
49702 wxPyEndAllowThreads(__tstate);
49703 if (PyErr_Occurred()) SWIG_fail;
49704 }
49705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49706 return resultobj;
49707 fail:
49708 return NULL;
49709 }
49710
49711
49712 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49713 PyObject *resultobj = 0;
49714 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49715 void *argp1 = 0 ;
49716 int res1 = 0 ;
49717 PyObject *swig_obj[1] ;
49718
49719 if (!args) SWIG_fail;
49720 swig_obj[0] = args;
49721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49722 if (!SWIG_IsOK(res1)) {
49723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49724 }
49725 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49726 {
49727 PyThreadState* __tstate = wxPyBeginAllowThreads();
49728 delete arg1;
49729
49730 wxPyEndAllowThreads(__tstate);
49731 if (PyErr_Occurred()) SWIG_fail;
49732 }
49733 resultobj = SWIG_Py_Void();
49734 return resultobj;
49735 fail:
49736 return NULL;
49737 }
49738
49739
49740 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49741 PyObject *resultobj = 0;
49742 wxWindow *arg1 = (wxWindow *) 0 ;
49743 wxGBPosition *arg2 = 0 ;
49744 wxGBSpan *arg3 = 0 ;
49745 int arg4 ;
49746 int arg5 ;
49747 PyObject *arg6 = (PyObject *) NULL ;
49748 wxGBSizerItem *result = 0 ;
49749 void *argp1 = 0 ;
49750 int res1 = 0 ;
49751 wxGBPosition temp2 ;
49752 wxGBSpan temp3 ;
49753 int val4 ;
49754 int ecode4 = 0 ;
49755 int val5 ;
49756 int ecode5 = 0 ;
49757 PyObject * obj0 = 0 ;
49758 PyObject * obj1 = 0 ;
49759 PyObject * obj2 = 0 ;
49760 PyObject * obj3 = 0 ;
49761 PyObject * obj4 = 0 ;
49762 PyObject * obj5 = 0 ;
49763 char * kwnames[] = {
49764 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49765 };
49766
49767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49769 if (!SWIG_IsOK(res1)) {
49770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49771 }
49772 arg1 = reinterpret_cast< wxWindow * >(argp1);
49773 {
49774 arg2 = &temp2;
49775 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49776 }
49777 {
49778 arg3 = &temp3;
49779 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49780 }
49781 ecode4 = SWIG_AsVal_int(obj3, &val4);
49782 if (!SWIG_IsOK(ecode4)) {
49783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49784 }
49785 arg4 = static_cast< int >(val4);
49786 ecode5 = SWIG_AsVal_int(obj4, &val5);
49787 if (!SWIG_IsOK(ecode5)) {
49788 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49789 }
49790 arg5 = static_cast< int >(val5);
49791 if (obj5) {
49792 arg6 = obj5;
49793 }
49794 {
49795 PyThreadState* __tstate = wxPyBeginAllowThreads();
49796 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49797 wxPyEndAllowThreads(__tstate);
49798 if (PyErr_Occurred()) SWIG_fail;
49799 }
49800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49801 return resultobj;
49802 fail:
49803 return NULL;
49804 }
49805
49806
49807 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49808 PyObject *resultobj = 0;
49809 wxSizer *arg1 = (wxSizer *) 0 ;
49810 wxGBPosition *arg2 = 0 ;
49811 wxGBSpan *arg3 = 0 ;
49812 int arg4 ;
49813 int arg5 ;
49814 PyObject *arg6 = (PyObject *) NULL ;
49815 wxGBSizerItem *result = 0 ;
49816 int res1 = 0 ;
49817 wxGBPosition temp2 ;
49818 wxGBSpan temp3 ;
49819 int val4 ;
49820 int ecode4 = 0 ;
49821 int val5 ;
49822 int ecode5 = 0 ;
49823 PyObject * obj0 = 0 ;
49824 PyObject * obj1 = 0 ;
49825 PyObject * obj2 = 0 ;
49826 PyObject * obj3 = 0 ;
49827 PyObject * obj4 = 0 ;
49828 PyObject * obj5 = 0 ;
49829 char * kwnames[] = {
49830 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49831 };
49832
49833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49834 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49835 if (!SWIG_IsOK(res1)) {
49836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49837 }
49838 {
49839 arg2 = &temp2;
49840 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49841 }
49842 {
49843 arg3 = &temp3;
49844 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49845 }
49846 ecode4 = SWIG_AsVal_int(obj3, &val4);
49847 if (!SWIG_IsOK(ecode4)) {
49848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49849 }
49850 arg4 = static_cast< int >(val4);
49851 ecode5 = SWIG_AsVal_int(obj4, &val5);
49852 if (!SWIG_IsOK(ecode5)) {
49853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49854 }
49855 arg5 = static_cast< int >(val5);
49856 if (obj5) {
49857 arg6 = obj5;
49858 }
49859 {
49860 PyThreadState* __tstate = wxPyBeginAllowThreads();
49861 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49862 wxPyEndAllowThreads(__tstate);
49863 if (PyErr_Occurred()) SWIG_fail;
49864 }
49865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49866 return resultobj;
49867 fail:
49868 return NULL;
49869 }
49870
49871
49872 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49873 PyObject *resultobj = 0;
49874 int arg1 ;
49875 int arg2 ;
49876 wxGBPosition *arg3 = 0 ;
49877 wxGBSpan *arg4 = 0 ;
49878 int arg5 ;
49879 int arg6 ;
49880 PyObject *arg7 = (PyObject *) NULL ;
49881 wxGBSizerItem *result = 0 ;
49882 int val1 ;
49883 int ecode1 = 0 ;
49884 int val2 ;
49885 int ecode2 = 0 ;
49886 wxGBPosition temp3 ;
49887 wxGBSpan temp4 ;
49888 int val5 ;
49889 int ecode5 = 0 ;
49890 int val6 ;
49891 int ecode6 = 0 ;
49892 PyObject * obj0 = 0 ;
49893 PyObject * obj1 = 0 ;
49894 PyObject * obj2 = 0 ;
49895 PyObject * obj3 = 0 ;
49896 PyObject * obj4 = 0 ;
49897 PyObject * obj5 = 0 ;
49898 PyObject * obj6 = 0 ;
49899 char * kwnames[] = {
49900 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49901 };
49902
49903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49904 ecode1 = SWIG_AsVal_int(obj0, &val1);
49905 if (!SWIG_IsOK(ecode1)) {
49906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49907 }
49908 arg1 = static_cast< int >(val1);
49909 ecode2 = SWIG_AsVal_int(obj1, &val2);
49910 if (!SWIG_IsOK(ecode2)) {
49911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49912 }
49913 arg2 = static_cast< int >(val2);
49914 {
49915 arg3 = &temp3;
49916 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49917 }
49918 {
49919 arg4 = &temp4;
49920 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49921 }
49922 ecode5 = SWIG_AsVal_int(obj4, &val5);
49923 if (!SWIG_IsOK(ecode5)) {
49924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49925 }
49926 arg5 = static_cast< int >(val5);
49927 ecode6 = SWIG_AsVal_int(obj5, &val6);
49928 if (!SWIG_IsOK(ecode6)) {
49929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49930 }
49931 arg6 = static_cast< int >(val6);
49932 if (obj6) {
49933 arg7 = obj6;
49934 }
49935 {
49936 PyThreadState* __tstate = wxPyBeginAllowThreads();
49937 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49938 wxPyEndAllowThreads(__tstate);
49939 if (PyErr_Occurred()) SWIG_fail;
49940 }
49941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49942 return resultobj;
49943 fail:
49944 return NULL;
49945 }
49946
49947
49948 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49949 PyObject *resultobj = 0;
49950 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49951 wxGBPosition result;
49952 void *argp1 = 0 ;
49953 int res1 = 0 ;
49954 PyObject *swig_obj[1] ;
49955
49956 if (!args) SWIG_fail;
49957 swig_obj[0] = args;
49958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49959 if (!SWIG_IsOK(res1)) {
49960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49961 }
49962 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49963 {
49964 PyThreadState* __tstate = wxPyBeginAllowThreads();
49965 result = ((wxGBSizerItem const *)arg1)->GetPos();
49966 wxPyEndAllowThreads(__tstate);
49967 if (PyErr_Occurred()) SWIG_fail;
49968 }
49969 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49970 return resultobj;
49971 fail:
49972 return NULL;
49973 }
49974
49975
49976 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49977 PyObject *resultobj = 0;
49978 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49979 wxGBSpan result;
49980 void *argp1 = 0 ;
49981 int res1 = 0 ;
49982 PyObject *swig_obj[1] ;
49983
49984 if (!args) SWIG_fail;
49985 swig_obj[0] = args;
49986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49987 if (!SWIG_IsOK(res1)) {
49988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49989 }
49990 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49991 {
49992 PyThreadState* __tstate = wxPyBeginAllowThreads();
49993 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49994 wxPyEndAllowThreads(__tstate);
49995 if (PyErr_Occurred()) SWIG_fail;
49996 }
49997 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49998 return resultobj;
49999 fail:
50000 return NULL;
50001 }
50002
50003
50004 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50005 PyObject *resultobj = 0;
50006 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50007 wxGBPosition *arg2 = 0 ;
50008 bool result;
50009 void *argp1 = 0 ;
50010 int res1 = 0 ;
50011 wxGBPosition temp2 ;
50012 PyObject * obj0 = 0 ;
50013 PyObject * obj1 = 0 ;
50014 char * kwnames[] = {
50015 (char *) "self",(char *) "pos", NULL
50016 };
50017
50018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50020 if (!SWIG_IsOK(res1)) {
50021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50022 }
50023 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50024 {
50025 arg2 = &temp2;
50026 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50027 }
50028 {
50029 PyThreadState* __tstate = wxPyBeginAllowThreads();
50030 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50031 wxPyEndAllowThreads(__tstate);
50032 if (PyErr_Occurred()) SWIG_fail;
50033 }
50034 {
50035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50036 }
50037 return resultobj;
50038 fail:
50039 return NULL;
50040 }
50041
50042
50043 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50044 PyObject *resultobj = 0;
50045 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50046 wxGBSpan *arg2 = 0 ;
50047 bool result;
50048 void *argp1 = 0 ;
50049 int res1 = 0 ;
50050 wxGBSpan temp2 ;
50051 PyObject * obj0 = 0 ;
50052 PyObject * obj1 = 0 ;
50053 char * kwnames[] = {
50054 (char *) "self",(char *) "span", NULL
50055 };
50056
50057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50059 if (!SWIG_IsOK(res1)) {
50060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50061 }
50062 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50063 {
50064 arg2 = &temp2;
50065 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50066 }
50067 {
50068 PyThreadState* __tstate = wxPyBeginAllowThreads();
50069 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50070 wxPyEndAllowThreads(__tstate);
50071 if (PyErr_Occurred()) SWIG_fail;
50072 }
50073 {
50074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50075 }
50076 return resultobj;
50077 fail:
50078 return NULL;
50079 }
50080
50081
50082 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50083 PyObject *resultobj = 0;
50084 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50085 wxGBSizerItem *arg2 = 0 ;
50086 bool result;
50087 void *argp1 = 0 ;
50088 int res1 = 0 ;
50089 void *argp2 = 0 ;
50090 int res2 = 0 ;
50091 PyObject * obj0 = 0 ;
50092 PyObject * obj1 = 0 ;
50093 char * kwnames[] = {
50094 (char *) "self",(char *) "other", NULL
50095 };
50096
50097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50099 if (!SWIG_IsOK(res1)) {
50100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50101 }
50102 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50103 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50104 if (!SWIG_IsOK(res2)) {
50105 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50106 }
50107 if (!argp2) {
50108 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50109 }
50110 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 {
50118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50119 }
50120 return resultobj;
50121 fail:
50122 return NULL;
50123 }
50124
50125
50126 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50127 PyObject *resultobj = 0;
50128 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50129 wxGBPosition *arg2 = 0 ;
50130 wxGBSpan *arg3 = 0 ;
50131 bool result;
50132 void *argp1 = 0 ;
50133 int res1 = 0 ;
50134 wxGBPosition temp2 ;
50135 wxGBSpan temp3 ;
50136 PyObject * obj0 = 0 ;
50137 PyObject * obj1 = 0 ;
50138 PyObject * obj2 = 0 ;
50139 char * kwnames[] = {
50140 (char *) "self",(char *) "pos",(char *) "span", NULL
50141 };
50142
50143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50145 if (!SWIG_IsOK(res1)) {
50146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50147 }
50148 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50149 {
50150 arg2 = &temp2;
50151 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50152 }
50153 {
50154 arg3 = &temp3;
50155 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50156 }
50157 {
50158 PyThreadState* __tstate = wxPyBeginAllowThreads();
50159 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50160 wxPyEndAllowThreads(__tstate);
50161 if (PyErr_Occurred()) SWIG_fail;
50162 }
50163 {
50164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50165 }
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50173 PyObject *resultobj = 0;
50174 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50175 wxGBPosition result;
50176 void *argp1 = 0 ;
50177 int res1 = 0 ;
50178 PyObject *swig_obj[1] ;
50179
50180 if (!args) SWIG_fail;
50181 swig_obj[0] = args;
50182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50183 if (!SWIG_IsOK(res1)) {
50184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50185 }
50186 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50187 {
50188 PyThreadState* __tstate = wxPyBeginAllowThreads();
50189 result = wxGBSizerItem_GetEndPos(arg1);
50190 wxPyEndAllowThreads(__tstate);
50191 if (PyErr_Occurred()) SWIG_fail;
50192 }
50193 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50194 return resultobj;
50195 fail:
50196 return NULL;
50197 }
50198
50199
50200 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50201 PyObject *resultobj = 0;
50202 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50203 wxGridBagSizer *result = 0 ;
50204 void *argp1 = 0 ;
50205 int res1 = 0 ;
50206 PyObject *swig_obj[1] ;
50207
50208 if (!args) SWIG_fail;
50209 swig_obj[0] = args;
50210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50211 if (!SWIG_IsOK(res1)) {
50212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50213 }
50214 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50215 {
50216 PyThreadState* __tstate = wxPyBeginAllowThreads();
50217 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50218 wxPyEndAllowThreads(__tstate);
50219 if (PyErr_Occurred()) SWIG_fail;
50220 }
50221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50222 return resultobj;
50223 fail:
50224 return NULL;
50225 }
50226
50227
50228 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50229 PyObject *resultobj = 0;
50230 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50231 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50232 void *argp1 = 0 ;
50233 int res1 = 0 ;
50234 void *argp2 = 0 ;
50235 int res2 = 0 ;
50236 PyObject * obj0 = 0 ;
50237 PyObject * obj1 = 0 ;
50238 char * kwnames[] = {
50239 (char *) "self",(char *) "sizer", NULL
50240 };
50241
50242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50244 if (!SWIG_IsOK(res1)) {
50245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50246 }
50247 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50249 if (!SWIG_IsOK(res2)) {
50250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50251 }
50252 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50253 {
50254 PyThreadState* __tstate = wxPyBeginAllowThreads();
50255 (arg1)->SetGBSizer(arg2);
50256 wxPyEndAllowThreads(__tstate);
50257 if (PyErr_Occurred()) SWIG_fail;
50258 }
50259 resultobj = SWIG_Py_Void();
50260 return resultobj;
50261 fail:
50262 return NULL;
50263 }
50264
50265
50266 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50267 PyObject *obj;
50268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50269 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50270 return SWIG_Py_Void();
50271 }
50272
50273 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50274 return SWIG_Python_InitShadowInstance(args);
50275 }
50276
50277 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50278 PyObject *resultobj = 0;
50279 int arg1 = (int) 0 ;
50280 int arg2 = (int) 0 ;
50281 wxGridBagSizer *result = 0 ;
50282 int val1 ;
50283 int ecode1 = 0 ;
50284 int val2 ;
50285 int ecode2 = 0 ;
50286 PyObject * obj0 = 0 ;
50287 PyObject * obj1 = 0 ;
50288 char * kwnames[] = {
50289 (char *) "vgap",(char *) "hgap", NULL
50290 };
50291
50292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50293 if (obj0) {
50294 ecode1 = SWIG_AsVal_int(obj0, &val1);
50295 if (!SWIG_IsOK(ecode1)) {
50296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50297 }
50298 arg1 = static_cast< int >(val1);
50299 }
50300 if (obj1) {
50301 ecode2 = SWIG_AsVal_int(obj1, &val2);
50302 if (!SWIG_IsOK(ecode2)) {
50303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50304 }
50305 arg2 = static_cast< int >(val2);
50306 }
50307 {
50308 PyThreadState* __tstate = wxPyBeginAllowThreads();
50309 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50310 wxPyEndAllowThreads(__tstate);
50311 if (PyErr_Occurred()) SWIG_fail;
50312 }
50313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50314 return resultobj;
50315 fail:
50316 return NULL;
50317 }
50318
50319
50320 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50321 PyObject *resultobj = 0;
50322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50323 PyObject *arg2 = (PyObject *) 0 ;
50324 wxGBPosition *arg3 = 0 ;
50325 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50326 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50327 int arg5 = (int) 0 ;
50328 int arg6 = (int) 0 ;
50329 PyObject *arg7 = (PyObject *) NULL ;
50330 wxGBSizerItem *result = 0 ;
50331 void *argp1 = 0 ;
50332 int res1 = 0 ;
50333 wxGBPosition temp3 ;
50334 wxGBSpan temp4 ;
50335 int val5 ;
50336 int ecode5 = 0 ;
50337 int val6 ;
50338 int ecode6 = 0 ;
50339 PyObject * obj0 = 0 ;
50340 PyObject * obj1 = 0 ;
50341 PyObject * obj2 = 0 ;
50342 PyObject * obj3 = 0 ;
50343 PyObject * obj4 = 0 ;
50344 PyObject * obj5 = 0 ;
50345 PyObject * obj6 = 0 ;
50346 char * kwnames[] = {
50347 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50348 };
50349
50350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50352 if (!SWIG_IsOK(res1)) {
50353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50354 }
50355 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50356 arg2 = obj1;
50357 {
50358 arg3 = &temp3;
50359 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50360 }
50361 if (obj3) {
50362 {
50363 arg4 = &temp4;
50364 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50365 }
50366 }
50367 if (obj4) {
50368 ecode5 = SWIG_AsVal_int(obj4, &val5);
50369 if (!SWIG_IsOK(ecode5)) {
50370 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50371 }
50372 arg5 = static_cast< int >(val5);
50373 }
50374 if (obj5) {
50375 ecode6 = SWIG_AsVal_int(obj5, &val6);
50376 if (!SWIG_IsOK(ecode6)) {
50377 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50378 }
50379 arg6 = static_cast< int >(val6);
50380 }
50381 if (obj6) {
50382 arg7 = obj6;
50383 }
50384 {
50385 PyThreadState* __tstate = wxPyBeginAllowThreads();
50386 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50387 wxPyEndAllowThreads(__tstate);
50388 if (PyErr_Occurred()) SWIG_fail;
50389 }
50390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50391 return resultobj;
50392 fail:
50393 return NULL;
50394 }
50395
50396
50397 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50398 PyObject *resultobj = 0;
50399 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50400 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50401 wxGBSizerItem *result = 0 ;
50402 void *argp1 = 0 ;
50403 int res1 = 0 ;
50404 int res2 = 0 ;
50405 PyObject * obj0 = 0 ;
50406 PyObject * obj1 = 0 ;
50407 char * kwnames[] = {
50408 (char *) "self",(char *) "item", NULL
50409 };
50410
50411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50413 if (!SWIG_IsOK(res1)) {
50414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50415 }
50416 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50417 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50418 if (!SWIG_IsOK(res2)) {
50419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50420 }
50421 {
50422 PyThreadState* __tstate = wxPyBeginAllowThreads();
50423 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50424 wxPyEndAllowThreads(__tstate);
50425 if (PyErr_Occurred()) SWIG_fail;
50426 }
50427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50428 return resultobj;
50429 fail:
50430 return NULL;
50431 }
50432
50433
50434 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50435 PyObject *resultobj = 0;
50436 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50437 int arg2 ;
50438 int arg3 ;
50439 wxSize result;
50440 void *argp1 = 0 ;
50441 int res1 = 0 ;
50442 int val2 ;
50443 int ecode2 = 0 ;
50444 int val3 ;
50445 int ecode3 = 0 ;
50446 PyObject * obj0 = 0 ;
50447 PyObject * obj1 = 0 ;
50448 PyObject * obj2 = 0 ;
50449 char * kwnames[] = {
50450 (char *) "self",(char *) "row",(char *) "col", NULL
50451 };
50452
50453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50455 if (!SWIG_IsOK(res1)) {
50456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50457 }
50458 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50459 ecode2 = SWIG_AsVal_int(obj1, &val2);
50460 if (!SWIG_IsOK(ecode2)) {
50461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50462 }
50463 arg2 = static_cast< int >(val2);
50464 ecode3 = SWIG_AsVal_int(obj2, &val3);
50465 if (!SWIG_IsOK(ecode3)) {
50466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50467 }
50468 arg3 = static_cast< int >(val3);
50469 {
50470 PyThreadState* __tstate = wxPyBeginAllowThreads();
50471 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50472 wxPyEndAllowThreads(__tstate);
50473 if (PyErr_Occurred()) SWIG_fail;
50474 }
50475 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50476 return resultobj;
50477 fail:
50478 return NULL;
50479 }
50480
50481
50482 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50483 PyObject *resultobj = 0;
50484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50485 wxSize result;
50486 void *argp1 = 0 ;
50487 int res1 = 0 ;
50488 PyObject *swig_obj[1] ;
50489
50490 if (!args) SWIG_fail;
50491 swig_obj[0] = args;
50492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50493 if (!SWIG_IsOK(res1)) {
50494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50495 }
50496 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50497 {
50498 PyThreadState* __tstate = wxPyBeginAllowThreads();
50499 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50500 wxPyEndAllowThreads(__tstate);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50504 return resultobj;
50505 fail:
50506 return NULL;
50507 }
50508
50509
50510 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50511 PyObject *resultobj = 0;
50512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50513 wxSize *arg2 = 0 ;
50514 void *argp1 = 0 ;
50515 int res1 = 0 ;
50516 wxSize temp2 ;
50517 PyObject * obj0 = 0 ;
50518 PyObject * obj1 = 0 ;
50519 char * kwnames[] = {
50520 (char *) "self",(char *) "sz", NULL
50521 };
50522
50523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50525 if (!SWIG_IsOK(res1)) {
50526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50527 }
50528 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50529 {
50530 arg2 = &temp2;
50531 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50532 }
50533 {
50534 PyThreadState* __tstate = wxPyBeginAllowThreads();
50535 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50536 wxPyEndAllowThreads(__tstate);
50537 if (PyErr_Occurred()) SWIG_fail;
50538 }
50539 resultobj = SWIG_Py_Void();
50540 return resultobj;
50541 fail:
50542 return NULL;
50543 }
50544
50545
50546 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50547 PyObject *resultobj = 0;
50548 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50549 wxWindow *arg2 = (wxWindow *) 0 ;
50550 wxGBPosition result;
50551 void *argp1 = 0 ;
50552 int res1 = 0 ;
50553 void *argp2 = 0 ;
50554 int res2 = 0 ;
50555
50556 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50558 if (!SWIG_IsOK(res1)) {
50559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50560 }
50561 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50562 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50563 if (!SWIG_IsOK(res2)) {
50564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50565 }
50566 arg2 = reinterpret_cast< wxWindow * >(argp2);
50567 {
50568 PyThreadState* __tstate = wxPyBeginAllowThreads();
50569 result = (arg1)->GetItemPosition(arg2);
50570 wxPyEndAllowThreads(__tstate);
50571 if (PyErr_Occurred()) SWIG_fail;
50572 }
50573 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50574 return resultobj;
50575 fail:
50576 return NULL;
50577 }
50578
50579
50580 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50581 PyObject *resultobj = 0;
50582 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50583 wxSizer *arg2 = (wxSizer *) 0 ;
50584 wxGBPosition result;
50585 void *argp1 = 0 ;
50586 int res1 = 0 ;
50587 void *argp2 = 0 ;
50588 int res2 = 0 ;
50589
50590 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50592 if (!SWIG_IsOK(res1)) {
50593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50594 }
50595 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50596 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50597 if (!SWIG_IsOK(res2)) {
50598 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50599 }
50600 arg2 = reinterpret_cast< wxSizer * >(argp2);
50601 {
50602 PyThreadState* __tstate = wxPyBeginAllowThreads();
50603 result = (arg1)->GetItemPosition(arg2);
50604 wxPyEndAllowThreads(__tstate);
50605 if (PyErr_Occurred()) SWIG_fail;
50606 }
50607 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50608 return resultobj;
50609 fail:
50610 return NULL;
50611 }
50612
50613
50614 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50615 PyObject *resultobj = 0;
50616 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50617 size_t arg2 ;
50618 wxGBPosition result;
50619 void *argp1 = 0 ;
50620 int res1 = 0 ;
50621 size_t val2 ;
50622 int ecode2 = 0 ;
50623
50624 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50626 if (!SWIG_IsOK(res1)) {
50627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50628 }
50629 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50630 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50631 if (!SWIG_IsOK(ecode2)) {
50632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50633 }
50634 arg2 = static_cast< size_t >(val2);
50635 {
50636 PyThreadState* __tstate = wxPyBeginAllowThreads();
50637 result = (arg1)->GetItemPosition(arg2);
50638 wxPyEndAllowThreads(__tstate);
50639 if (PyErr_Occurred()) SWIG_fail;
50640 }
50641 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50642 return resultobj;
50643 fail:
50644 return NULL;
50645 }
50646
50647
50648 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50649 int argc;
50650 PyObject *argv[3];
50651
50652 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50653 --argc;
50654 if (argc == 2) {
50655 int _v = 0;
50656 {
50657 void *vptr = 0;
50658 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50659 _v = SWIG_CheckState(res);
50660 }
50661 if (!_v) goto check_1;
50662 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50663 }
50664 check_1:
50665
50666 if (argc == 2) {
50667 int _v = 0;
50668 {
50669 void *vptr = 0;
50670 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50671 _v = SWIG_CheckState(res);
50672 }
50673 if (!_v) goto check_2;
50674 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50675 }
50676 check_2:
50677
50678 if (argc == 2) {
50679 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50680 }
50681
50682 fail:
50683 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50684 return NULL;
50685 }
50686
50687
50688 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50689 PyObject *resultobj = 0;
50690 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50691 wxWindow *arg2 = (wxWindow *) 0 ;
50692 wxGBPosition *arg3 = 0 ;
50693 bool result;
50694 void *argp1 = 0 ;
50695 int res1 = 0 ;
50696 void *argp2 = 0 ;
50697 int res2 = 0 ;
50698 wxGBPosition temp3 ;
50699
50700 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50702 if (!SWIG_IsOK(res1)) {
50703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50704 }
50705 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50706 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50707 if (!SWIG_IsOK(res2)) {
50708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50709 }
50710 arg2 = reinterpret_cast< wxWindow * >(argp2);
50711 {
50712 arg3 = &temp3;
50713 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50714 }
50715 {
50716 PyThreadState* __tstate = wxPyBeginAllowThreads();
50717 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50718 wxPyEndAllowThreads(__tstate);
50719 if (PyErr_Occurred()) SWIG_fail;
50720 }
50721 {
50722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50723 }
50724 return resultobj;
50725 fail:
50726 return NULL;
50727 }
50728
50729
50730 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50731 PyObject *resultobj = 0;
50732 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50733 wxSizer *arg2 = (wxSizer *) 0 ;
50734 wxGBPosition *arg3 = 0 ;
50735 bool result;
50736 void *argp1 = 0 ;
50737 int res1 = 0 ;
50738 void *argp2 = 0 ;
50739 int res2 = 0 ;
50740 wxGBPosition temp3 ;
50741
50742 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50744 if (!SWIG_IsOK(res1)) {
50745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50746 }
50747 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50748 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50749 if (!SWIG_IsOK(res2)) {
50750 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50751 }
50752 arg2 = reinterpret_cast< wxSizer * >(argp2);
50753 {
50754 arg3 = &temp3;
50755 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50756 }
50757 {
50758 PyThreadState* __tstate = wxPyBeginAllowThreads();
50759 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50760 wxPyEndAllowThreads(__tstate);
50761 if (PyErr_Occurred()) SWIG_fail;
50762 }
50763 {
50764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50765 }
50766 return resultobj;
50767 fail:
50768 return NULL;
50769 }
50770
50771
50772 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50773 PyObject *resultobj = 0;
50774 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50775 size_t arg2 ;
50776 wxGBPosition *arg3 = 0 ;
50777 bool result;
50778 void *argp1 = 0 ;
50779 int res1 = 0 ;
50780 size_t val2 ;
50781 int ecode2 = 0 ;
50782 wxGBPosition temp3 ;
50783
50784 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50786 if (!SWIG_IsOK(res1)) {
50787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50788 }
50789 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50790 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50791 if (!SWIG_IsOK(ecode2)) {
50792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50793 }
50794 arg2 = static_cast< size_t >(val2);
50795 {
50796 arg3 = &temp3;
50797 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50798 }
50799 {
50800 PyThreadState* __tstate = wxPyBeginAllowThreads();
50801 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50802 wxPyEndAllowThreads(__tstate);
50803 if (PyErr_Occurred()) SWIG_fail;
50804 }
50805 {
50806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50807 }
50808 return resultobj;
50809 fail:
50810 return NULL;
50811 }
50812
50813
50814 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50815 int argc;
50816 PyObject *argv[4];
50817
50818 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50819 --argc;
50820 if (argc == 3) {
50821 int _v = 0;
50822 {
50823 void *vptr = 0;
50824 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50825 _v = SWIG_CheckState(res);
50826 }
50827 if (!_v) goto check_1;
50828 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50829 }
50830 check_1:
50831
50832 if (argc == 3) {
50833 int _v = 0;
50834 {
50835 void *vptr = 0;
50836 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50837 _v = SWIG_CheckState(res);
50838 }
50839 if (!_v) goto check_2;
50840 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50841 }
50842 check_2:
50843
50844 if (argc == 3) {
50845 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50846 }
50847
50848 fail:
50849 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50850 return NULL;
50851 }
50852
50853
50854 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50855 PyObject *resultobj = 0;
50856 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50857 wxWindow *arg2 = (wxWindow *) 0 ;
50858 wxGBSpan result;
50859 void *argp1 = 0 ;
50860 int res1 = 0 ;
50861 void *argp2 = 0 ;
50862 int res2 = 0 ;
50863
50864 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50866 if (!SWIG_IsOK(res1)) {
50867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50868 }
50869 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50870 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50871 if (!SWIG_IsOK(res2)) {
50872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50873 }
50874 arg2 = reinterpret_cast< wxWindow * >(argp2);
50875 {
50876 PyThreadState* __tstate = wxPyBeginAllowThreads();
50877 result = (arg1)->GetItemSpan(arg2);
50878 wxPyEndAllowThreads(__tstate);
50879 if (PyErr_Occurred()) SWIG_fail;
50880 }
50881 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50882 return resultobj;
50883 fail:
50884 return NULL;
50885 }
50886
50887
50888 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50889 PyObject *resultobj = 0;
50890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50891 wxSizer *arg2 = (wxSizer *) 0 ;
50892 wxGBSpan result;
50893 void *argp1 = 0 ;
50894 int res1 = 0 ;
50895 void *argp2 = 0 ;
50896 int res2 = 0 ;
50897
50898 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50900 if (!SWIG_IsOK(res1)) {
50901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50902 }
50903 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50904 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50905 if (!SWIG_IsOK(res2)) {
50906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50907 }
50908 arg2 = reinterpret_cast< wxSizer * >(argp2);
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 result = (arg1)->GetItemSpan(arg2);
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50923 PyObject *resultobj = 0;
50924 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50925 size_t arg2 ;
50926 wxGBSpan result;
50927 void *argp1 = 0 ;
50928 int res1 = 0 ;
50929 size_t val2 ;
50930 int ecode2 = 0 ;
50931
50932 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50934 if (!SWIG_IsOK(res1)) {
50935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50936 }
50937 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50938 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50939 if (!SWIG_IsOK(ecode2)) {
50940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50941 }
50942 arg2 = static_cast< size_t >(val2);
50943 {
50944 PyThreadState* __tstate = wxPyBeginAllowThreads();
50945 result = (arg1)->GetItemSpan(arg2);
50946 wxPyEndAllowThreads(__tstate);
50947 if (PyErr_Occurred()) SWIG_fail;
50948 }
50949 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50950 return resultobj;
50951 fail:
50952 return NULL;
50953 }
50954
50955
50956 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50957 int argc;
50958 PyObject *argv[3];
50959
50960 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50961 --argc;
50962 if (argc == 2) {
50963 int _v = 0;
50964 {
50965 void *vptr = 0;
50966 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50967 _v = SWIG_CheckState(res);
50968 }
50969 if (!_v) goto check_1;
50970 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50971 }
50972 check_1:
50973
50974 if (argc == 2) {
50975 int _v = 0;
50976 {
50977 void *vptr = 0;
50978 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50979 _v = SWIG_CheckState(res);
50980 }
50981 if (!_v) goto check_2;
50982 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50983 }
50984 check_2:
50985
50986 if (argc == 2) {
50987 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50988 }
50989
50990 fail:
50991 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50992 return NULL;
50993 }
50994
50995
50996 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50997 PyObject *resultobj = 0;
50998 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50999 wxWindow *arg2 = (wxWindow *) 0 ;
51000 wxGBSpan *arg3 = 0 ;
51001 bool result;
51002 void *argp1 = 0 ;
51003 int res1 = 0 ;
51004 void *argp2 = 0 ;
51005 int res2 = 0 ;
51006 wxGBSpan temp3 ;
51007
51008 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51010 if (!SWIG_IsOK(res1)) {
51011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51012 }
51013 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51014 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51015 if (!SWIG_IsOK(res2)) {
51016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51017 }
51018 arg2 = reinterpret_cast< wxWindow * >(argp2);
51019 {
51020 arg3 = &temp3;
51021 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51022 }
51023 {
51024 PyThreadState* __tstate = wxPyBeginAllowThreads();
51025 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51026 wxPyEndAllowThreads(__tstate);
51027 if (PyErr_Occurred()) SWIG_fail;
51028 }
51029 {
51030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51031 }
51032 return resultobj;
51033 fail:
51034 return NULL;
51035 }
51036
51037
51038 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51039 PyObject *resultobj = 0;
51040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51041 wxSizer *arg2 = (wxSizer *) 0 ;
51042 wxGBSpan *arg3 = 0 ;
51043 bool result;
51044 void *argp1 = 0 ;
51045 int res1 = 0 ;
51046 void *argp2 = 0 ;
51047 int res2 = 0 ;
51048 wxGBSpan temp3 ;
51049
51050 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51052 if (!SWIG_IsOK(res1)) {
51053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51054 }
51055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51056 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51057 if (!SWIG_IsOK(res2)) {
51058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51059 }
51060 arg2 = reinterpret_cast< wxSizer * >(argp2);
51061 {
51062 arg3 = &temp3;
51063 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51064 }
51065 {
51066 PyThreadState* __tstate = wxPyBeginAllowThreads();
51067 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51068 wxPyEndAllowThreads(__tstate);
51069 if (PyErr_Occurred()) SWIG_fail;
51070 }
51071 {
51072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51073 }
51074 return resultobj;
51075 fail:
51076 return NULL;
51077 }
51078
51079
51080 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51081 PyObject *resultobj = 0;
51082 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51083 size_t arg2 ;
51084 wxGBSpan *arg3 = 0 ;
51085 bool result;
51086 void *argp1 = 0 ;
51087 int res1 = 0 ;
51088 size_t val2 ;
51089 int ecode2 = 0 ;
51090 wxGBSpan temp3 ;
51091
51092 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51094 if (!SWIG_IsOK(res1)) {
51095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51096 }
51097 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51098 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51099 if (!SWIG_IsOK(ecode2)) {
51100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51101 }
51102 arg2 = static_cast< size_t >(val2);
51103 {
51104 arg3 = &temp3;
51105 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51106 }
51107 {
51108 PyThreadState* __tstate = wxPyBeginAllowThreads();
51109 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51110 wxPyEndAllowThreads(__tstate);
51111 if (PyErr_Occurred()) SWIG_fail;
51112 }
51113 {
51114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51115 }
51116 return resultobj;
51117 fail:
51118 return NULL;
51119 }
51120
51121
51122 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51123 int argc;
51124 PyObject *argv[4];
51125
51126 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51127 --argc;
51128 if (argc == 3) {
51129 int _v = 0;
51130 {
51131 void *vptr = 0;
51132 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51133 _v = SWIG_CheckState(res);
51134 }
51135 if (!_v) goto check_1;
51136 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51137 }
51138 check_1:
51139
51140 if (argc == 3) {
51141 int _v = 0;
51142 {
51143 void *vptr = 0;
51144 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51145 _v = SWIG_CheckState(res);
51146 }
51147 if (!_v) goto check_2;
51148 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51149 }
51150 check_2:
51151
51152 if (argc == 3) {
51153 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51154 }
51155
51156 fail:
51157 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51158 return NULL;
51159 }
51160
51161
51162 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51163 PyObject *resultobj = 0;
51164 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51165 wxWindow *arg2 = (wxWindow *) 0 ;
51166 wxGBSizerItem *result = 0 ;
51167 void *argp1 = 0 ;
51168 int res1 = 0 ;
51169 void *argp2 = 0 ;
51170 int res2 = 0 ;
51171
51172 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51174 if (!SWIG_IsOK(res1)) {
51175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51176 }
51177 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51178 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51179 if (!SWIG_IsOK(res2)) {
51180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51181 }
51182 arg2 = reinterpret_cast< wxWindow * >(argp2);
51183 {
51184 PyThreadState* __tstate = wxPyBeginAllowThreads();
51185 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51186 wxPyEndAllowThreads(__tstate);
51187 if (PyErr_Occurred()) SWIG_fail;
51188 }
51189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51190 return resultobj;
51191 fail:
51192 return NULL;
51193 }
51194
51195
51196 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51197 PyObject *resultobj = 0;
51198 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51199 wxSizer *arg2 = (wxSizer *) 0 ;
51200 wxGBSizerItem *result = 0 ;
51201 void *argp1 = 0 ;
51202 int res1 = 0 ;
51203 void *argp2 = 0 ;
51204 int res2 = 0 ;
51205
51206 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51208 if (!SWIG_IsOK(res1)) {
51209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51210 }
51211 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51213 if (!SWIG_IsOK(res2)) {
51214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51215 }
51216 arg2 = reinterpret_cast< wxSizer * >(argp2);
51217 {
51218 PyThreadState* __tstate = wxPyBeginAllowThreads();
51219 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51220 wxPyEndAllowThreads(__tstate);
51221 if (PyErr_Occurred()) SWIG_fail;
51222 }
51223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51224 return resultobj;
51225 fail:
51226 return NULL;
51227 }
51228
51229
51230 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51231 int argc;
51232 PyObject *argv[3];
51233
51234 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51235 --argc;
51236 if (argc == 2) {
51237 int _v = 0;
51238 {
51239 void *vptr = 0;
51240 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51241 _v = SWIG_CheckState(res);
51242 }
51243 if (!_v) goto check_1;
51244 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51245 }
51246 check_1:
51247
51248 if (argc == 2) {
51249 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51250 }
51251
51252 fail:
51253 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51254 return NULL;
51255 }
51256
51257
51258 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51259 PyObject *resultobj = 0;
51260 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51261 wxGBPosition *arg2 = 0 ;
51262 wxGBSizerItem *result = 0 ;
51263 void *argp1 = 0 ;
51264 int res1 = 0 ;
51265 wxGBPosition temp2 ;
51266 PyObject * obj0 = 0 ;
51267 PyObject * obj1 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "pos", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51278 {
51279 arg2 = &temp2;
51280 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51281 }
51282 {
51283 PyThreadState* __tstate = wxPyBeginAllowThreads();
51284 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51285 wxPyEndAllowThreads(__tstate);
51286 if (PyErr_Occurred()) SWIG_fail;
51287 }
51288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51289 return resultobj;
51290 fail:
51291 return NULL;
51292 }
51293
51294
51295 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51296 PyObject *resultobj = 0;
51297 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51298 wxPoint *arg2 = 0 ;
51299 wxGBSizerItem *result = 0 ;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 wxPoint temp2 ;
51303 PyObject * obj0 = 0 ;
51304 PyObject * obj1 = 0 ;
51305 char * kwnames[] = {
51306 (char *) "self",(char *) "pt", NULL
51307 };
51308
51309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51311 if (!SWIG_IsOK(res1)) {
51312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51313 }
51314 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51315 {
51316 arg2 = &temp2;
51317 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51318 }
51319 {
51320 PyThreadState* __tstate = wxPyBeginAllowThreads();
51321 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51322 wxPyEndAllowThreads(__tstate);
51323 if (PyErr_Occurred()) SWIG_fail;
51324 }
51325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51326 return resultobj;
51327 fail:
51328 return NULL;
51329 }
51330
51331
51332 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51333 PyObject *resultobj = 0;
51334 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51335 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51336 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51337 bool result;
51338 void *argp1 = 0 ;
51339 int res1 = 0 ;
51340 void *argp2 = 0 ;
51341 int res2 = 0 ;
51342 void *argp3 = 0 ;
51343 int res3 = 0 ;
51344 PyObject * obj0 = 0 ;
51345 PyObject * obj1 = 0 ;
51346 PyObject * obj2 = 0 ;
51347 char * kwnames[] = {
51348 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51349 };
51350
51351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51353 if (!SWIG_IsOK(res1)) {
51354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51355 }
51356 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51358 if (!SWIG_IsOK(res2)) {
51359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51360 }
51361 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51362 if (obj2) {
51363 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51364 if (!SWIG_IsOK(res3)) {
51365 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51366 }
51367 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51368 }
51369 {
51370 PyThreadState* __tstate = wxPyBeginAllowThreads();
51371 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51372 wxPyEndAllowThreads(__tstate);
51373 if (PyErr_Occurred()) SWIG_fail;
51374 }
51375 {
51376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51377 }
51378 return resultobj;
51379 fail:
51380 return NULL;
51381 }
51382
51383
51384 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51385 PyObject *resultobj = 0;
51386 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51387 wxGBPosition *arg2 = 0 ;
51388 wxGBSpan *arg3 = 0 ;
51389 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51390 bool result;
51391 void *argp1 = 0 ;
51392 int res1 = 0 ;
51393 wxGBPosition temp2 ;
51394 wxGBSpan temp3 ;
51395 void *argp4 = 0 ;
51396 int res4 = 0 ;
51397 PyObject * obj0 = 0 ;
51398 PyObject * obj1 = 0 ;
51399 PyObject * obj2 = 0 ;
51400 PyObject * obj3 = 0 ;
51401 char * kwnames[] = {
51402 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51403 };
51404
51405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51407 if (!SWIG_IsOK(res1)) {
51408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51409 }
51410 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51411 {
51412 arg2 = &temp2;
51413 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51414 }
51415 {
51416 arg3 = &temp3;
51417 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51418 }
51419 if (obj3) {
51420 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51421 if (!SWIG_IsOK(res4)) {
51422 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51423 }
51424 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51425 }
51426 {
51427 PyThreadState* __tstate = wxPyBeginAllowThreads();
51428 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51429 wxPyEndAllowThreads(__tstate);
51430 if (PyErr_Occurred()) SWIG_fail;
51431 }
51432 {
51433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51434 }
51435 return resultobj;
51436 fail:
51437 return NULL;
51438 }
51439
51440
51441 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51442 PyObject *obj;
51443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51444 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51445 return SWIG_Py_Void();
51446 }
51447
51448 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51449 return SWIG_Python_InitShadowInstance(args);
51450 }
51451
51452 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51453 PyObject *resultobj = 0;
51454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51455 wxRelationship arg2 ;
51456 wxWindow *arg3 = (wxWindow *) 0 ;
51457 wxEdge arg4 ;
51458 int arg5 = (int) 0 ;
51459 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51460 void *argp1 = 0 ;
51461 int res1 = 0 ;
51462 int val2 ;
51463 int ecode2 = 0 ;
51464 void *argp3 = 0 ;
51465 int res3 = 0 ;
51466 int val4 ;
51467 int ecode4 = 0 ;
51468 int val5 ;
51469 int ecode5 = 0 ;
51470 int val6 ;
51471 int ecode6 = 0 ;
51472 PyObject * obj0 = 0 ;
51473 PyObject * obj1 = 0 ;
51474 PyObject * obj2 = 0 ;
51475 PyObject * obj3 = 0 ;
51476 PyObject * obj4 = 0 ;
51477 PyObject * obj5 = 0 ;
51478 char * kwnames[] = {
51479 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51480 };
51481
51482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51484 if (!SWIG_IsOK(res1)) {
51485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51486 }
51487 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51488 ecode2 = SWIG_AsVal_int(obj1, &val2);
51489 if (!SWIG_IsOK(ecode2)) {
51490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51491 }
51492 arg2 = static_cast< wxRelationship >(val2);
51493 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51494 if (!SWIG_IsOK(res3)) {
51495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51496 }
51497 arg3 = reinterpret_cast< wxWindow * >(argp3);
51498 ecode4 = SWIG_AsVal_int(obj3, &val4);
51499 if (!SWIG_IsOK(ecode4)) {
51500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51501 }
51502 arg4 = static_cast< wxEdge >(val4);
51503 if (obj4) {
51504 ecode5 = SWIG_AsVal_int(obj4, &val5);
51505 if (!SWIG_IsOK(ecode5)) {
51506 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51507 }
51508 arg5 = static_cast< int >(val5);
51509 }
51510 if (obj5) {
51511 ecode6 = SWIG_AsVal_int(obj5, &val6);
51512 if (!SWIG_IsOK(ecode6)) {
51513 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51514 }
51515 arg6 = static_cast< int >(val6);
51516 }
51517 {
51518 PyThreadState* __tstate = wxPyBeginAllowThreads();
51519 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51520 wxPyEndAllowThreads(__tstate);
51521 if (PyErr_Occurred()) SWIG_fail;
51522 }
51523 resultobj = SWIG_Py_Void();
51524 return resultobj;
51525 fail:
51526 return NULL;
51527 }
51528
51529
51530 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51531 PyObject *resultobj = 0;
51532 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51533 wxWindow *arg2 = (wxWindow *) 0 ;
51534 int arg3 = (int) 0 ;
51535 void *argp1 = 0 ;
51536 int res1 = 0 ;
51537 void *argp2 = 0 ;
51538 int res2 = 0 ;
51539 int val3 ;
51540 int ecode3 = 0 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 PyObject * obj2 = 0 ;
51544 char * kwnames[] = {
51545 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51546 };
51547
51548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51550 if (!SWIG_IsOK(res1)) {
51551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51552 }
51553 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51554 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51555 if (!SWIG_IsOK(res2)) {
51556 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51557 }
51558 arg2 = reinterpret_cast< wxWindow * >(argp2);
51559 if (obj2) {
51560 ecode3 = SWIG_AsVal_int(obj2, &val3);
51561 if (!SWIG_IsOK(ecode3)) {
51562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51563 }
51564 arg3 = static_cast< int >(val3);
51565 }
51566 {
51567 PyThreadState* __tstate = wxPyBeginAllowThreads();
51568 (arg1)->LeftOf(arg2,arg3);
51569 wxPyEndAllowThreads(__tstate);
51570 if (PyErr_Occurred()) SWIG_fail;
51571 }
51572 resultobj = SWIG_Py_Void();
51573 return resultobj;
51574 fail:
51575 return NULL;
51576 }
51577
51578
51579 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51580 PyObject *resultobj = 0;
51581 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51582 wxWindow *arg2 = (wxWindow *) 0 ;
51583 int arg3 = (int) 0 ;
51584 void *argp1 = 0 ;
51585 int res1 = 0 ;
51586 void *argp2 = 0 ;
51587 int res2 = 0 ;
51588 int val3 ;
51589 int ecode3 = 0 ;
51590 PyObject * obj0 = 0 ;
51591 PyObject * obj1 = 0 ;
51592 PyObject * obj2 = 0 ;
51593 char * kwnames[] = {
51594 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51595 };
51596
51597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51599 if (!SWIG_IsOK(res1)) {
51600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51601 }
51602 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51603 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51604 if (!SWIG_IsOK(res2)) {
51605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51606 }
51607 arg2 = reinterpret_cast< wxWindow * >(argp2);
51608 if (obj2) {
51609 ecode3 = SWIG_AsVal_int(obj2, &val3);
51610 if (!SWIG_IsOK(ecode3)) {
51611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51612 }
51613 arg3 = static_cast< int >(val3);
51614 }
51615 {
51616 PyThreadState* __tstate = wxPyBeginAllowThreads();
51617 (arg1)->RightOf(arg2,arg3);
51618 wxPyEndAllowThreads(__tstate);
51619 if (PyErr_Occurred()) SWIG_fail;
51620 }
51621 resultobj = SWIG_Py_Void();
51622 return resultobj;
51623 fail:
51624 return NULL;
51625 }
51626
51627
51628 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51629 PyObject *resultobj = 0;
51630 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51631 wxWindow *arg2 = (wxWindow *) 0 ;
51632 int arg3 = (int) 0 ;
51633 void *argp1 = 0 ;
51634 int res1 = 0 ;
51635 void *argp2 = 0 ;
51636 int res2 = 0 ;
51637 int val3 ;
51638 int ecode3 = 0 ;
51639 PyObject * obj0 = 0 ;
51640 PyObject * obj1 = 0 ;
51641 PyObject * obj2 = 0 ;
51642 char * kwnames[] = {
51643 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51644 };
51645
51646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51648 if (!SWIG_IsOK(res1)) {
51649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51650 }
51651 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51652 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51653 if (!SWIG_IsOK(res2)) {
51654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51655 }
51656 arg2 = reinterpret_cast< wxWindow * >(argp2);
51657 if (obj2) {
51658 ecode3 = SWIG_AsVal_int(obj2, &val3);
51659 if (!SWIG_IsOK(ecode3)) {
51660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51661 }
51662 arg3 = static_cast< int >(val3);
51663 }
51664 {
51665 PyThreadState* __tstate = wxPyBeginAllowThreads();
51666 (arg1)->Above(arg2,arg3);
51667 wxPyEndAllowThreads(__tstate);
51668 if (PyErr_Occurred()) SWIG_fail;
51669 }
51670 resultobj = SWIG_Py_Void();
51671 return resultobj;
51672 fail:
51673 return NULL;
51674 }
51675
51676
51677 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51678 PyObject *resultobj = 0;
51679 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51680 wxWindow *arg2 = (wxWindow *) 0 ;
51681 int arg3 = (int) 0 ;
51682 void *argp1 = 0 ;
51683 int res1 = 0 ;
51684 void *argp2 = 0 ;
51685 int res2 = 0 ;
51686 int val3 ;
51687 int ecode3 = 0 ;
51688 PyObject * obj0 = 0 ;
51689 PyObject * obj1 = 0 ;
51690 PyObject * obj2 = 0 ;
51691 char * kwnames[] = {
51692 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51693 };
51694
51695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51697 if (!SWIG_IsOK(res1)) {
51698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51699 }
51700 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51702 if (!SWIG_IsOK(res2)) {
51703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51704 }
51705 arg2 = reinterpret_cast< wxWindow * >(argp2);
51706 if (obj2) {
51707 ecode3 = SWIG_AsVal_int(obj2, &val3);
51708 if (!SWIG_IsOK(ecode3)) {
51709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51710 }
51711 arg3 = static_cast< int >(val3);
51712 }
51713 {
51714 PyThreadState* __tstate = wxPyBeginAllowThreads();
51715 (arg1)->Below(arg2,arg3);
51716 wxPyEndAllowThreads(__tstate);
51717 if (PyErr_Occurred()) SWIG_fail;
51718 }
51719 resultobj = SWIG_Py_Void();
51720 return resultobj;
51721 fail:
51722 return NULL;
51723 }
51724
51725
51726 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51727 PyObject *resultobj = 0;
51728 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51729 wxWindow *arg2 = (wxWindow *) 0 ;
51730 wxEdge arg3 ;
51731 int arg4 = (int) 0 ;
51732 void *argp1 = 0 ;
51733 int res1 = 0 ;
51734 void *argp2 = 0 ;
51735 int res2 = 0 ;
51736 int val3 ;
51737 int ecode3 = 0 ;
51738 int val4 ;
51739 int ecode4 = 0 ;
51740 PyObject * obj0 = 0 ;
51741 PyObject * obj1 = 0 ;
51742 PyObject * obj2 = 0 ;
51743 PyObject * obj3 = 0 ;
51744 char * kwnames[] = {
51745 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51746 };
51747
51748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51750 if (!SWIG_IsOK(res1)) {
51751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51752 }
51753 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51755 if (!SWIG_IsOK(res2)) {
51756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51757 }
51758 arg2 = reinterpret_cast< wxWindow * >(argp2);
51759 ecode3 = SWIG_AsVal_int(obj2, &val3);
51760 if (!SWIG_IsOK(ecode3)) {
51761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51762 }
51763 arg3 = static_cast< wxEdge >(val3);
51764 if (obj3) {
51765 ecode4 = SWIG_AsVal_int(obj3, &val4);
51766 if (!SWIG_IsOK(ecode4)) {
51767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51768 }
51769 arg4 = static_cast< int >(val4);
51770 }
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 (arg1)->SameAs(arg2,arg3,arg4);
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_Py_Void();
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51785 PyObject *resultobj = 0;
51786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51787 wxWindow *arg2 = (wxWindow *) 0 ;
51788 wxEdge arg3 ;
51789 int arg4 ;
51790 void *argp1 = 0 ;
51791 int res1 = 0 ;
51792 void *argp2 = 0 ;
51793 int res2 = 0 ;
51794 int val3 ;
51795 int ecode3 = 0 ;
51796 int val4 ;
51797 int ecode4 = 0 ;
51798 PyObject * obj0 = 0 ;
51799 PyObject * obj1 = 0 ;
51800 PyObject * obj2 = 0 ;
51801 PyObject * obj3 = 0 ;
51802 char * kwnames[] = {
51803 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51804 };
51805
51806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51808 if (!SWIG_IsOK(res1)) {
51809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51810 }
51811 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51813 if (!SWIG_IsOK(res2)) {
51814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51815 }
51816 arg2 = reinterpret_cast< wxWindow * >(argp2);
51817 ecode3 = SWIG_AsVal_int(obj2, &val3);
51818 if (!SWIG_IsOK(ecode3)) {
51819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51820 }
51821 arg3 = static_cast< wxEdge >(val3);
51822 ecode4 = SWIG_AsVal_int(obj3, &val4);
51823 if (!SWIG_IsOK(ecode4)) {
51824 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51825 }
51826 arg4 = static_cast< int >(val4);
51827 {
51828 PyThreadState* __tstate = wxPyBeginAllowThreads();
51829 (arg1)->PercentOf(arg2,arg3,arg4);
51830 wxPyEndAllowThreads(__tstate);
51831 if (PyErr_Occurred()) SWIG_fail;
51832 }
51833 resultobj = SWIG_Py_Void();
51834 return resultobj;
51835 fail:
51836 return NULL;
51837 }
51838
51839
51840 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51841 PyObject *resultobj = 0;
51842 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51843 int arg2 ;
51844 void *argp1 = 0 ;
51845 int res1 = 0 ;
51846 int val2 ;
51847 int ecode2 = 0 ;
51848 PyObject * obj0 = 0 ;
51849 PyObject * obj1 = 0 ;
51850 char * kwnames[] = {
51851 (char *) "self",(char *) "val", NULL
51852 };
51853
51854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51856 if (!SWIG_IsOK(res1)) {
51857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51858 }
51859 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51860 ecode2 = SWIG_AsVal_int(obj1, &val2);
51861 if (!SWIG_IsOK(ecode2)) {
51862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51863 }
51864 arg2 = static_cast< int >(val2);
51865 {
51866 PyThreadState* __tstate = wxPyBeginAllowThreads();
51867 (arg1)->Absolute(arg2);
51868 wxPyEndAllowThreads(__tstate);
51869 if (PyErr_Occurred()) SWIG_fail;
51870 }
51871 resultobj = SWIG_Py_Void();
51872 return resultobj;
51873 fail:
51874 return NULL;
51875 }
51876
51877
51878 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51879 PyObject *resultobj = 0;
51880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51881 void *argp1 = 0 ;
51882 int res1 = 0 ;
51883 PyObject *swig_obj[1] ;
51884
51885 if (!args) SWIG_fail;
51886 swig_obj[0] = args;
51887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51888 if (!SWIG_IsOK(res1)) {
51889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51890 }
51891 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51892 {
51893 PyThreadState* __tstate = wxPyBeginAllowThreads();
51894 (arg1)->Unconstrained();
51895 wxPyEndAllowThreads(__tstate);
51896 if (PyErr_Occurred()) SWIG_fail;
51897 }
51898 resultobj = SWIG_Py_Void();
51899 return resultobj;
51900 fail:
51901 return NULL;
51902 }
51903
51904
51905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51906 PyObject *resultobj = 0;
51907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51908 void *argp1 = 0 ;
51909 int res1 = 0 ;
51910 PyObject *swig_obj[1] ;
51911
51912 if (!args) SWIG_fail;
51913 swig_obj[0] = args;
51914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51915 if (!SWIG_IsOK(res1)) {
51916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51917 }
51918 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51919 {
51920 PyThreadState* __tstate = wxPyBeginAllowThreads();
51921 (arg1)->AsIs();
51922 wxPyEndAllowThreads(__tstate);
51923 if (PyErr_Occurred()) SWIG_fail;
51924 }
51925 resultobj = SWIG_Py_Void();
51926 return resultobj;
51927 fail:
51928 return NULL;
51929 }
51930
51931
51932 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51933 PyObject *resultobj = 0;
51934 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51935 wxWindow *result = 0 ;
51936 void *argp1 = 0 ;
51937 int res1 = 0 ;
51938 PyObject *swig_obj[1] ;
51939
51940 if (!args) SWIG_fail;
51941 swig_obj[0] = args;
51942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51943 if (!SWIG_IsOK(res1)) {
51944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51945 }
51946 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51947 {
51948 PyThreadState* __tstate = wxPyBeginAllowThreads();
51949 result = (wxWindow *)(arg1)->GetOtherWindow();
51950 wxPyEndAllowThreads(__tstate);
51951 if (PyErr_Occurred()) SWIG_fail;
51952 }
51953 {
51954 resultobj = wxPyMake_wxObject(result, 0);
51955 }
51956 return resultobj;
51957 fail:
51958 return NULL;
51959 }
51960
51961
51962 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51963 PyObject *resultobj = 0;
51964 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51965 wxEdge result;
51966 void *argp1 = 0 ;
51967 int res1 = 0 ;
51968 PyObject *swig_obj[1] ;
51969
51970 if (!args) SWIG_fail;
51971 swig_obj[0] = args;
51972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51973 if (!SWIG_IsOK(res1)) {
51974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51975 }
51976 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51977 {
51978 PyThreadState* __tstate = wxPyBeginAllowThreads();
51979 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51980 wxPyEndAllowThreads(__tstate);
51981 if (PyErr_Occurred()) SWIG_fail;
51982 }
51983 resultobj = SWIG_From_int(static_cast< int >(result));
51984 return resultobj;
51985 fail:
51986 return NULL;
51987 }
51988
51989
51990 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51991 PyObject *resultobj = 0;
51992 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51993 wxEdge arg2 ;
51994 void *argp1 = 0 ;
51995 int res1 = 0 ;
51996 int val2 ;
51997 int ecode2 = 0 ;
51998 PyObject * obj0 = 0 ;
51999 PyObject * obj1 = 0 ;
52000 char * kwnames[] = {
52001 (char *) "self",(char *) "which", NULL
52002 };
52003
52004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52006 if (!SWIG_IsOK(res1)) {
52007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52008 }
52009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52010 ecode2 = SWIG_AsVal_int(obj1, &val2);
52011 if (!SWIG_IsOK(ecode2)) {
52012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52013 }
52014 arg2 = static_cast< wxEdge >(val2);
52015 {
52016 PyThreadState* __tstate = wxPyBeginAllowThreads();
52017 (arg1)->SetEdge(arg2);
52018 wxPyEndAllowThreads(__tstate);
52019 if (PyErr_Occurred()) SWIG_fail;
52020 }
52021 resultobj = SWIG_Py_Void();
52022 return resultobj;
52023 fail:
52024 return NULL;
52025 }
52026
52027
52028 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52029 PyObject *resultobj = 0;
52030 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52031 int arg2 ;
52032 void *argp1 = 0 ;
52033 int res1 = 0 ;
52034 int val2 ;
52035 int ecode2 = 0 ;
52036 PyObject * obj0 = 0 ;
52037 PyObject * obj1 = 0 ;
52038 char * kwnames[] = {
52039 (char *) "self",(char *) "v", NULL
52040 };
52041
52042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52044 if (!SWIG_IsOK(res1)) {
52045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52046 }
52047 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52048 ecode2 = SWIG_AsVal_int(obj1, &val2);
52049 if (!SWIG_IsOK(ecode2)) {
52050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52051 }
52052 arg2 = static_cast< int >(val2);
52053 {
52054 PyThreadState* __tstate = wxPyBeginAllowThreads();
52055 (arg1)->SetValue(arg2);
52056 wxPyEndAllowThreads(__tstate);
52057 if (PyErr_Occurred()) SWIG_fail;
52058 }
52059 resultobj = SWIG_Py_Void();
52060 return resultobj;
52061 fail:
52062 return NULL;
52063 }
52064
52065
52066 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52067 PyObject *resultobj = 0;
52068 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52069 int result;
52070 void *argp1 = 0 ;
52071 int res1 = 0 ;
52072 PyObject *swig_obj[1] ;
52073
52074 if (!args) SWIG_fail;
52075 swig_obj[0] = args;
52076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52077 if (!SWIG_IsOK(res1)) {
52078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52079 }
52080 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52081 {
52082 PyThreadState* __tstate = wxPyBeginAllowThreads();
52083 result = (int)(arg1)->GetMargin();
52084 wxPyEndAllowThreads(__tstate);
52085 if (PyErr_Occurred()) SWIG_fail;
52086 }
52087 resultobj = SWIG_From_int(static_cast< int >(result));
52088 return resultobj;
52089 fail:
52090 return NULL;
52091 }
52092
52093
52094 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52095 PyObject *resultobj = 0;
52096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52097 int arg2 ;
52098 void *argp1 = 0 ;
52099 int res1 = 0 ;
52100 int val2 ;
52101 int ecode2 = 0 ;
52102 PyObject * obj0 = 0 ;
52103 PyObject * obj1 = 0 ;
52104 char * kwnames[] = {
52105 (char *) "self",(char *) "m", NULL
52106 };
52107
52108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52110 if (!SWIG_IsOK(res1)) {
52111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52112 }
52113 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52114 ecode2 = SWIG_AsVal_int(obj1, &val2);
52115 if (!SWIG_IsOK(ecode2)) {
52116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52117 }
52118 arg2 = static_cast< int >(val2);
52119 {
52120 PyThreadState* __tstate = wxPyBeginAllowThreads();
52121 (arg1)->SetMargin(arg2);
52122 wxPyEndAllowThreads(__tstate);
52123 if (PyErr_Occurred()) SWIG_fail;
52124 }
52125 resultobj = SWIG_Py_Void();
52126 return resultobj;
52127 fail:
52128 return NULL;
52129 }
52130
52131
52132 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52133 PyObject *resultobj = 0;
52134 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52135 int result;
52136 void *argp1 = 0 ;
52137 int res1 = 0 ;
52138 PyObject *swig_obj[1] ;
52139
52140 if (!args) SWIG_fail;
52141 swig_obj[0] = args;
52142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52143 if (!SWIG_IsOK(res1)) {
52144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52145 }
52146 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52147 {
52148 PyThreadState* __tstate = wxPyBeginAllowThreads();
52149 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52150 wxPyEndAllowThreads(__tstate);
52151 if (PyErr_Occurred()) SWIG_fail;
52152 }
52153 resultobj = SWIG_From_int(static_cast< int >(result));
52154 return resultobj;
52155 fail:
52156 return NULL;
52157 }
52158
52159
52160 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52161 PyObject *resultobj = 0;
52162 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52163 int result;
52164 void *argp1 = 0 ;
52165 int res1 = 0 ;
52166 PyObject *swig_obj[1] ;
52167
52168 if (!args) SWIG_fail;
52169 swig_obj[0] = args;
52170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52171 if (!SWIG_IsOK(res1)) {
52172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52173 }
52174 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52175 {
52176 PyThreadState* __tstate = wxPyBeginAllowThreads();
52177 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52178 wxPyEndAllowThreads(__tstate);
52179 if (PyErr_Occurred()) SWIG_fail;
52180 }
52181 resultobj = SWIG_From_int(static_cast< int >(result));
52182 return resultobj;
52183 fail:
52184 return NULL;
52185 }
52186
52187
52188 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52189 PyObject *resultobj = 0;
52190 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52191 int result;
52192 void *argp1 = 0 ;
52193 int res1 = 0 ;
52194 PyObject *swig_obj[1] ;
52195
52196 if (!args) SWIG_fail;
52197 swig_obj[0] = args;
52198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52201 }
52202 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52203 {
52204 PyThreadState* __tstate = wxPyBeginAllowThreads();
52205 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52206 wxPyEndAllowThreads(__tstate);
52207 if (PyErr_Occurred()) SWIG_fail;
52208 }
52209 resultobj = SWIG_From_int(static_cast< int >(result));
52210 return resultobj;
52211 fail:
52212 return NULL;
52213 }
52214
52215
52216 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52217 PyObject *resultobj = 0;
52218 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52219 bool result;
52220 void *argp1 = 0 ;
52221 int res1 = 0 ;
52222 PyObject *swig_obj[1] ;
52223
52224 if (!args) SWIG_fail;
52225 swig_obj[0] = args;
52226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52227 if (!SWIG_IsOK(res1)) {
52228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52229 }
52230 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52231 {
52232 PyThreadState* __tstate = wxPyBeginAllowThreads();
52233 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52234 wxPyEndAllowThreads(__tstate);
52235 if (PyErr_Occurred()) SWIG_fail;
52236 }
52237 {
52238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52239 }
52240 return resultobj;
52241 fail:
52242 return NULL;
52243 }
52244
52245
52246 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52247 PyObject *resultobj = 0;
52248 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52249 bool arg2 ;
52250 void *argp1 = 0 ;
52251 int res1 = 0 ;
52252 bool val2 ;
52253 int ecode2 = 0 ;
52254 PyObject * obj0 = 0 ;
52255 PyObject * obj1 = 0 ;
52256 char * kwnames[] = {
52257 (char *) "self",(char *) "d", NULL
52258 };
52259
52260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52262 if (!SWIG_IsOK(res1)) {
52263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52264 }
52265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52267 if (!SWIG_IsOK(ecode2)) {
52268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52269 }
52270 arg2 = static_cast< bool >(val2);
52271 {
52272 PyThreadState* __tstate = wxPyBeginAllowThreads();
52273 (arg1)->SetDone(arg2);
52274 wxPyEndAllowThreads(__tstate);
52275 if (PyErr_Occurred()) SWIG_fail;
52276 }
52277 resultobj = SWIG_Py_Void();
52278 return resultobj;
52279 fail:
52280 return NULL;
52281 }
52282
52283
52284 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52285 PyObject *resultobj = 0;
52286 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52287 wxRelationship result;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 PyObject *swig_obj[1] ;
52291
52292 if (!args) SWIG_fail;
52293 swig_obj[0] = args;
52294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52295 if (!SWIG_IsOK(res1)) {
52296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52297 }
52298 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52299 {
52300 PyThreadState* __tstate = wxPyBeginAllowThreads();
52301 result = (wxRelationship)(arg1)->GetRelationship();
52302 wxPyEndAllowThreads(__tstate);
52303 if (PyErr_Occurred()) SWIG_fail;
52304 }
52305 resultobj = SWIG_From_int(static_cast< int >(result));
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52313 PyObject *resultobj = 0;
52314 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52315 wxRelationship arg2 ;
52316 void *argp1 = 0 ;
52317 int res1 = 0 ;
52318 int val2 ;
52319 int ecode2 = 0 ;
52320 PyObject * obj0 = 0 ;
52321 PyObject * obj1 = 0 ;
52322 char * kwnames[] = {
52323 (char *) "self",(char *) "r", NULL
52324 };
52325
52326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52328 if (!SWIG_IsOK(res1)) {
52329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52330 }
52331 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52332 ecode2 = SWIG_AsVal_int(obj1, &val2);
52333 if (!SWIG_IsOK(ecode2)) {
52334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52335 }
52336 arg2 = static_cast< wxRelationship >(val2);
52337 {
52338 PyThreadState* __tstate = wxPyBeginAllowThreads();
52339 (arg1)->SetRelationship(arg2);
52340 wxPyEndAllowThreads(__tstate);
52341 if (PyErr_Occurred()) SWIG_fail;
52342 }
52343 resultobj = SWIG_Py_Void();
52344 return resultobj;
52345 fail:
52346 return NULL;
52347 }
52348
52349
52350 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52351 PyObject *resultobj = 0;
52352 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52353 wxWindow *arg2 = (wxWindow *) 0 ;
52354 bool result;
52355 void *argp1 = 0 ;
52356 int res1 = 0 ;
52357 void *argp2 = 0 ;
52358 int res2 = 0 ;
52359 PyObject * obj0 = 0 ;
52360 PyObject * obj1 = 0 ;
52361 char * kwnames[] = {
52362 (char *) "self",(char *) "otherW", NULL
52363 };
52364
52365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52367 if (!SWIG_IsOK(res1)) {
52368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52369 }
52370 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52371 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52372 if (!SWIG_IsOK(res2)) {
52373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52374 }
52375 arg2 = reinterpret_cast< wxWindow * >(argp2);
52376 {
52377 PyThreadState* __tstate = wxPyBeginAllowThreads();
52378 result = (bool)(arg1)->ResetIfWin(arg2);
52379 wxPyEndAllowThreads(__tstate);
52380 if (PyErr_Occurred()) SWIG_fail;
52381 }
52382 {
52383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52384 }
52385 return resultobj;
52386 fail:
52387 return NULL;
52388 }
52389
52390
52391 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52392 PyObject *resultobj = 0;
52393 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52394 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52395 wxWindow *arg3 = (wxWindow *) 0 ;
52396 bool result;
52397 void *argp1 = 0 ;
52398 int res1 = 0 ;
52399 void *argp2 = 0 ;
52400 int res2 = 0 ;
52401 void *argp3 = 0 ;
52402 int res3 = 0 ;
52403 PyObject * obj0 = 0 ;
52404 PyObject * obj1 = 0 ;
52405 PyObject * obj2 = 0 ;
52406 char * kwnames[] = {
52407 (char *) "self",(char *) "constraints",(char *) "win", NULL
52408 };
52409
52410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52412 if (!SWIG_IsOK(res1)) {
52413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52414 }
52415 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52417 if (!SWIG_IsOK(res2)) {
52418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52419 }
52420 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52421 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52422 if (!SWIG_IsOK(res3)) {
52423 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52424 }
52425 arg3 = reinterpret_cast< wxWindow * >(argp3);
52426 {
52427 PyThreadState* __tstate = wxPyBeginAllowThreads();
52428 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52429 wxPyEndAllowThreads(__tstate);
52430 if (PyErr_Occurred()) SWIG_fail;
52431 }
52432 {
52433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52434 }
52435 return resultobj;
52436 fail:
52437 return NULL;
52438 }
52439
52440
52441 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52442 PyObject *resultobj = 0;
52443 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52444 wxEdge arg2 ;
52445 wxWindow *arg3 = (wxWindow *) 0 ;
52446 wxWindow *arg4 = (wxWindow *) 0 ;
52447 int result;
52448 void *argp1 = 0 ;
52449 int res1 = 0 ;
52450 int val2 ;
52451 int ecode2 = 0 ;
52452 void *argp3 = 0 ;
52453 int res3 = 0 ;
52454 void *argp4 = 0 ;
52455 int res4 = 0 ;
52456 PyObject * obj0 = 0 ;
52457 PyObject * obj1 = 0 ;
52458 PyObject * obj2 = 0 ;
52459 PyObject * obj3 = 0 ;
52460 char * kwnames[] = {
52461 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52462 };
52463
52464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52466 if (!SWIG_IsOK(res1)) {
52467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52468 }
52469 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52470 ecode2 = SWIG_AsVal_int(obj1, &val2);
52471 if (!SWIG_IsOK(ecode2)) {
52472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52473 }
52474 arg2 = static_cast< wxEdge >(val2);
52475 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52476 if (!SWIG_IsOK(res3)) {
52477 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52478 }
52479 arg3 = reinterpret_cast< wxWindow * >(argp3);
52480 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52481 if (!SWIG_IsOK(res4)) {
52482 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52483 }
52484 arg4 = reinterpret_cast< wxWindow * >(argp4);
52485 {
52486 PyThreadState* __tstate = wxPyBeginAllowThreads();
52487 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52488 wxPyEndAllowThreads(__tstate);
52489 if (PyErr_Occurred()) SWIG_fail;
52490 }
52491 resultobj = SWIG_From_int(static_cast< int >(result));
52492 return resultobj;
52493 fail:
52494 return NULL;
52495 }
52496
52497
52498 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52499 PyObject *obj;
52500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52501 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52502 return SWIG_Py_Void();
52503 }
52504
52505 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52506 PyObject *resultobj = 0;
52507 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52508 wxIndividualLayoutConstraint *result = 0 ;
52509 void *argp1 = 0 ;
52510 int res1 = 0 ;
52511 PyObject *swig_obj[1] ;
52512
52513 if (!args) SWIG_fail;
52514 swig_obj[0] = args;
52515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52516 if (!SWIG_IsOK(res1)) {
52517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52518 }
52519 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52520 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52522 return resultobj;
52523 fail:
52524 return NULL;
52525 }
52526
52527
52528 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52529 PyObject *resultobj = 0;
52530 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52531 wxIndividualLayoutConstraint *result = 0 ;
52532 void *argp1 = 0 ;
52533 int res1 = 0 ;
52534 PyObject *swig_obj[1] ;
52535
52536 if (!args) SWIG_fail;
52537 swig_obj[0] = args;
52538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52539 if (!SWIG_IsOK(res1)) {
52540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52541 }
52542 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52543 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52545 return resultobj;
52546 fail:
52547 return NULL;
52548 }
52549
52550
52551 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52552 PyObject *resultobj = 0;
52553 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52554 wxIndividualLayoutConstraint *result = 0 ;
52555 void *argp1 = 0 ;
52556 int res1 = 0 ;
52557 PyObject *swig_obj[1] ;
52558
52559 if (!args) SWIG_fail;
52560 swig_obj[0] = args;
52561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52562 if (!SWIG_IsOK(res1)) {
52563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52564 }
52565 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52566 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52568 return resultobj;
52569 fail:
52570 return NULL;
52571 }
52572
52573
52574 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52575 PyObject *resultobj = 0;
52576 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52577 wxIndividualLayoutConstraint *result = 0 ;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 PyObject *swig_obj[1] ;
52581
52582 if (!args) SWIG_fail;
52583 swig_obj[0] = args;
52584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52585 if (!SWIG_IsOK(res1)) {
52586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52587 }
52588 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52589 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52591 return resultobj;
52592 fail:
52593 return NULL;
52594 }
52595
52596
52597 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52598 PyObject *resultobj = 0;
52599 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52600 wxIndividualLayoutConstraint *result = 0 ;
52601 void *argp1 = 0 ;
52602 int res1 = 0 ;
52603 PyObject *swig_obj[1] ;
52604
52605 if (!args) SWIG_fail;
52606 swig_obj[0] = args;
52607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52608 if (!SWIG_IsOK(res1)) {
52609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52610 }
52611 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52612 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52613 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52614 return resultobj;
52615 fail:
52616 return NULL;
52617 }
52618
52619
52620 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52621 PyObject *resultobj = 0;
52622 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52623 wxIndividualLayoutConstraint *result = 0 ;
52624 void *argp1 = 0 ;
52625 int res1 = 0 ;
52626 PyObject *swig_obj[1] ;
52627
52628 if (!args) SWIG_fail;
52629 swig_obj[0] = args;
52630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52631 if (!SWIG_IsOK(res1)) {
52632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52633 }
52634 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52635 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52636 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52637 return resultobj;
52638 fail:
52639 return NULL;
52640 }
52641
52642
52643 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52644 PyObject *resultobj = 0;
52645 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52646 wxIndividualLayoutConstraint *result = 0 ;
52647 void *argp1 = 0 ;
52648 int res1 = 0 ;
52649 PyObject *swig_obj[1] ;
52650
52651 if (!args) SWIG_fail;
52652 swig_obj[0] = args;
52653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52654 if (!SWIG_IsOK(res1)) {
52655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52656 }
52657 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52658 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52660 return resultobj;
52661 fail:
52662 return NULL;
52663 }
52664
52665
52666 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52667 PyObject *resultobj = 0;
52668 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52669 wxIndividualLayoutConstraint *result = 0 ;
52670 void *argp1 = 0 ;
52671 int res1 = 0 ;
52672 PyObject *swig_obj[1] ;
52673
52674 if (!args) SWIG_fail;
52675 swig_obj[0] = args;
52676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52677 if (!SWIG_IsOK(res1)) {
52678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52679 }
52680 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52681 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52683 return resultobj;
52684 fail:
52685 return NULL;
52686 }
52687
52688
52689 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52690 PyObject *resultobj = 0;
52691 wxLayoutConstraints *result = 0 ;
52692
52693 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52694 {
52695 PyThreadState* __tstate = wxPyBeginAllowThreads();
52696 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52697 wxPyEndAllowThreads(__tstate);
52698 if (PyErr_Occurred()) SWIG_fail;
52699 }
52700 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52701 return resultobj;
52702 fail:
52703 return NULL;
52704 }
52705
52706
52707 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52708 PyObject *resultobj = 0;
52709 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52710 void *argp1 = 0 ;
52711 int res1 = 0 ;
52712 PyObject *swig_obj[1] ;
52713
52714 if (!args) SWIG_fail;
52715 swig_obj[0] = args;
52716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52717 if (!SWIG_IsOK(res1)) {
52718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52719 }
52720 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52721 {
52722 PyThreadState* __tstate = wxPyBeginAllowThreads();
52723 delete arg1;
52724
52725 wxPyEndAllowThreads(__tstate);
52726 if (PyErr_Occurred()) SWIG_fail;
52727 }
52728 resultobj = SWIG_Py_Void();
52729 return resultobj;
52730 fail:
52731 return NULL;
52732 }
52733
52734
52735 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52736 PyObject *resultobj = 0;
52737 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52738 wxWindow *arg2 = (wxWindow *) 0 ;
52739 int *arg3 = (int *) 0 ;
52740 bool result;
52741 void *argp1 = 0 ;
52742 int res1 = 0 ;
52743 void *argp2 = 0 ;
52744 int res2 = 0 ;
52745 int temp3 ;
52746 int res3 = SWIG_TMPOBJ ;
52747 PyObject * obj0 = 0 ;
52748 PyObject * obj1 = 0 ;
52749 char * kwnames[] = {
52750 (char *) "self",(char *) "win", NULL
52751 };
52752
52753 arg3 = &temp3;
52754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52756 if (!SWIG_IsOK(res1)) {
52757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52758 }
52759 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52761 if (!SWIG_IsOK(res2)) {
52762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52763 }
52764 arg2 = reinterpret_cast< wxWindow * >(argp2);
52765 {
52766 PyThreadState* __tstate = wxPyBeginAllowThreads();
52767 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52768 wxPyEndAllowThreads(__tstate);
52769 if (PyErr_Occurred()) SWIG_fail;
52770 }
52771 {
52772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52773 }
52774 if (SWIG_IsTmpObj(res3)) {
52775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52776 } else {
52777 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52779 }
52780 return resultobj;
52781 fail:
52782 return NULL;
52783 }
52784
52785
52786 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52787 PyObject *resultobj = 0;
52788 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52789 bool result;
52790 void *argp1 = 0 ;
52791 int res1 = 0 ;
52792 PyObject *swig_obj[1] ;
52793
52794 if (!args) SWIG_fail;
52795 swig_obj[0] = args;
52796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52797 if (!SWIG_IsOK(res1)) {
52798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52799 }
52800 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52801 {
52802 PyThreadState* __tstate = wxPyBeginAllowThreads();
52803 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52804 wxPyEndAllowThreads(__tstate);
52805 if (PyErr_Occurred()) SWIG_fail;
52806 }
52807 {
52808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52809 }
52810 return resultobj;
52811 fail:
52812 return NULL;
52813 }
52814
52815
52816 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52817 PyObject *obj;
52818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52819 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52820 return SWIG_Py_Void();
52821 }
52822
52823 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52824 return SWIG_Python_InitShadowInstance(args);
52825 }
52826
52827 static PyMethodDef SwigMethods[] = {
52828 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52829 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52830 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52831 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52832 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52833 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52834 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52835 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52836 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52838 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52840 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52849 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52850 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52851 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52853 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52854 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52855 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52856 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52857 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52858 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52859 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52861 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52867 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52868 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52869 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52870 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52871 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52872 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52873 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52874 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52875 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52876 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52882 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52883 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52884 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52885 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52890 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52891 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52893 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52895 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52897 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52899 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52901 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52903 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52904 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52906 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52907 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52908 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52909 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52910 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52911 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52914 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52919 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52920 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52921 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52922 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52929 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52930 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52931 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52932 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52933 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52934 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52935 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52936 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52937 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52939 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52940 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52941 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52943 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52946 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52947 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52948 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52949 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52953 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52956 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52963 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52964 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52965 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52966 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52968 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52969 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52970 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52972 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52973 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52974 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52975 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52976 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52978 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52980 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52981 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52982 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52983 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52984 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52985 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52988 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52989 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52990 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52991 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52992 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52993 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52995 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52996 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52997 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52998 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52999 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53000 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53001 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53002 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53003 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53004 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53005 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53010 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53016 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53017 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53018 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53019 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53021 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53024 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53025 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53026 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53028 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53029 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53030 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53031 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53034 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53035 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53036 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53040 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53041 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53042 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53046 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53048 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53051 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53052 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53053 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53054 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53055 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53056 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53057 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53061 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53064 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53065 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53067 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53068 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53069 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53075 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53076 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53078 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53079 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53080 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53081 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53082 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53083 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53084 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53085 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53087 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53088 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53089 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53090 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53091 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53092 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53093 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53094 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53096 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53105 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53107 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53109 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53117 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53118 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53133 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53134 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53135 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53136 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53139 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53141 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53143 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53145 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53146 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53147 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53150 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53151 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53152 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53153 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53155 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53159 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53160 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53162 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53172 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53173 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53177 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53179 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53181 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53182 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53184 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53185 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53186 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53187 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53188 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53189 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53190 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53191 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53192 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53193 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53194 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53196 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53197 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53198 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53199 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53200 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53201 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53202 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53203 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53205 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53206 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53207 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53208 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53209 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53210 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53211 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53212 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53213 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53215 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53216 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53217 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53218 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53221 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53225 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53229 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53230 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53231 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53232 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53234 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53235 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53237 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53239 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53241 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53242 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53243 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53244 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53245 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53247 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53248 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53250 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53251 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53252 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53253 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53254 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53255 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53256 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53258 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53260 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53261 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53262 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53264 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53266 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53267 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53269 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53270 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53271 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53273 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53274 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53275 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53276 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53277 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53279 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53280 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53282 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53283 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53284 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53286 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53287 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53290 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53291 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53293 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53298 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53299 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53300 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53301 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53302 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53303 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53304 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53305 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53306 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53307 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53308 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53309 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53310 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53311 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53312 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53313 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53314 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53315 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53316 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53317 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53318 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53319 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53320 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53321 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53322 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53324 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53325 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53326 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53327 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53328 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53329 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53330 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53331 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53332 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53333 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53334 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53335 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53336 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53337 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53338 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53339 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53340 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53341 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53342 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53343 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53344 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53345 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53346 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53347 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53348 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53349 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53350 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53351 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53352 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53353 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53354 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53355 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53357 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53358 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53360 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53361 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53362 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53363 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53365 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53366 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53367 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53368 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53369 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53370 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53371 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53372 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53373 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53375 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53376 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53377 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53378 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53379 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53380 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53381 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53382 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53383 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53384 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53385 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53386 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53387 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53388 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53389 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53390 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53391 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53392 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53393 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53394 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53395 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53396 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53397 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53398 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53399 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53400 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53401 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53402 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53404 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53405 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53407 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53408 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53409 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53410 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53411 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53412 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53413 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53415 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53416 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53419 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53422 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53423 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53425 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53426 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53428 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53429 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53430 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53432 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53434 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53435 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53437 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53438 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53439 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53441 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53442 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53443 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53448 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53449 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53450 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53451 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53452 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53455 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53457 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53459 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53460 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53461 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53464 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53465 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53466 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53468 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53469 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53470 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53472 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53473 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53474 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53475 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53476 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53477 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53479 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53480 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53481 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53482 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53483 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53484 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53485 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53486 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53492 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53494 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53496 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53497 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53498 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53499 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53500 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53501 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53503 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53504 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53505 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53507 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53508 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53509 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53510 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53511 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53514 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53515 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53516 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53519 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53520 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53521 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53522 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53523 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53525 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53527 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53529 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53530 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53532 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53535 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53536 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53537 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53539 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53540 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53541 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53543 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53545 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53546 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53547 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53549 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53551 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53553 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53554 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53556 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53557 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53559 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53561 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53562 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53563 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53564 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53565 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53567 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53568 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53569 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53571 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53573 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53574 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53575 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53576 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53578 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53580 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53582 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53584 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53585 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53587 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53588 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53589 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53590 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53591 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53592 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53593 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53594 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53596 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53598 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53600 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53602 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53604 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53606 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53607 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53608 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53609 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53610 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53611 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53616 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53617 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53618 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53619 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53620 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53621 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53622 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53623 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53625 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53627 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53628 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53630 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53631 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53632 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53633 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53635 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53636 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53637 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53638 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53639 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53640 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53641 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53643 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53644 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53645 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53647 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53649 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53650 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53651 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53652 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53653 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53655 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53656 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53657 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53658 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53660 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53661 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53662 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53663 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53664 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53665 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53666 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53667 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53668 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53669 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53671 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53674 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53675 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53676 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53678 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53680 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53682 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53684 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53685 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53695 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53696 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53700 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53701 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53702 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53703 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53704 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53705 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53706 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53707 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53708 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53709 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53710 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53711 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53712 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53713 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53714 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53716 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53717 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53720 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53721 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53726 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53727 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53730 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53731 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53732 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53733 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53736 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53737 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53738 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53740 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53742 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53743 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53744 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53746 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53748 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53750 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53753 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53754 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53755 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53756 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53757 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53758 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53762 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53763 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53764 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53765 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53772 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53778 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53779 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53780 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53781 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53782 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53784 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53794 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53795 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53796 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53797 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53800 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53801 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53802 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53803 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53805 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53806 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53810 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53816 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53817 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53818 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53819 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53821 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53822 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53824 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53827 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53829 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53830 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53831 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53840 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53844 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53845 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53847 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53853 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53857 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53858 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53859 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53860 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53864 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53867 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53869 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53872 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53874 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53875 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53878 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53880 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53881 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53882 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53883 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53884 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53889 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53890 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53891 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53893 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53894 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53895 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53897 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53899 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53900 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53901 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53903 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53904 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53907 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53915 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53922 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53930 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53933 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53934 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53947 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53949 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53951 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53952 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53954 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53956 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53957 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53959 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53960 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53961 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53965 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53984 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53985 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53987 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
53988 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53990 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53991 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53992 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53994 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53995 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53998 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53999 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54001 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54002 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54004 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54007 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54008 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54010 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54012 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54014 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54015 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54017 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54018 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54021 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54023 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54025 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54027 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54030 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54032 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54033 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54034 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54036 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54037 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54038 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54040 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54042 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54043 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54045 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54047 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54048 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54052 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54056 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54057 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54059 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54060 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54063 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54065 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54067 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54068 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54069 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54070 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54074 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54075 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54076 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54077 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54079 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54080 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54085 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54086 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54087 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54088 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54089 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54091 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54093 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54095 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54096 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54098 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54100 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54103 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54104 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54105 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54107 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54108 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54109 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54111 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54112 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54114 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54120 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54123 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54124 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54125 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54126 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54127 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54128 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54134 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54135 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54139 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54140 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54142 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54143 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54145 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54147 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54148 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54150 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54151 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54152 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54158 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54159 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54160 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54161 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54162 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54163 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54170 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54172 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54173 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54174 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54175 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54176 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54177 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54179 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54183 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54184 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54185 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54186 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54187 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54188 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54189 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54191 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54192 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54193 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54199 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54200 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54201 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54203 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54204 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54205 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54211 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54212 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54213 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54214 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54215 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54219 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54220 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54225 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54226 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54227 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54228 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54229 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54234 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54235 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54236 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54237 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54238 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54239 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54240 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54245 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54246 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54247 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54250 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54255 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54256 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54257 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54258 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54261 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54262 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54263 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54264 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54265 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54266 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54268 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54273 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54274 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54275 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54276 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54277 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54278 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54279 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54280 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54281 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54282 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54283 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54285 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54286 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54287 { NULL, NULL, 0, NULL }
54288 };
54289
54290
54291 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54292
54293 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54294 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54295 }
54296 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54297 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54298 }
54299 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54300 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54301 }
54302 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54303 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54304 }
54305 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54306 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54307 }
54308 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54309 return (void *)((wxSizer *) ((wxGridSizer *) x));
54310 }
54311 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54312 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54313 }
54314 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54315 return (void *)((wxSizer *) ((wxPySizer *) x));
54316 }
54317 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54318 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54319 }
54320 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54321 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54322 }
54323 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54324 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54325 }
54326 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54327 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54328 }
54329 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54330 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54331 }
54332 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54333 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54334 }
54335 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54336 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54337 }
54338 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54339 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54340 }
54341 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54342 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54343 }
54344 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54346 }
54347 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54348 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54349 }
54350 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54351 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54352 }
54353 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54354 return (void *)((wxEvent *) ((wxPyEvent *) x));
54355 }
54356 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54357 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54358 }
54359 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54360 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54361 }
54362 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54363 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54364 }
54365 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54366 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54367 }
54368 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54369 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54370 }
54371 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54372 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54373 }
54374 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54375 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54376 }
54377 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54378 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54379 }
54380 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54381 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54382 }
54383 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54384 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54385 }
54386 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54387 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54388 }
54389 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54390 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54391 }
54392 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54393 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54394 }
54395 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54396 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54397 }
54398 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54399 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54400 }
54401 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54402 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54403 }
54404 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54405 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54406 }
54407 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54408 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54409 }
54410 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54411 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54412 }
54413 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54414 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54415 }
54416 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54417 return (void *)((wxEvent *) ((wxShowEvent *) x));
54418 }
54419 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54420 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54421 }
54422 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54423 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54424 }
54425 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54426 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54427 }
54428 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54429 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54430 }
54431 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54432 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54433 }
54434 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54435 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54436 }
54437 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54438 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54439 }
54440 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54441 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54442 }
54443 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54444 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54445 }
54446 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54447 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54448 }
54449 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54450 return (void *)((wxControl *) ((wxControlWithItems *) x));
54451 }
54452 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54453 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54454 }
54455 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54456 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54457 }
54458 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54459 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54460 }
54461 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54462 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54463 }
54464 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54465 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54466 }
54467 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54468 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54469 }
54470 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54471 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54472 }
54473 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54474 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54475 }
54476 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54477 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54478 }
54479 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54480 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54481 }
54482 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54483 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54484 }
54485 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54486 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54487 }
54488 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54489 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54490 }
54491 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54492 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54493 }
54494 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54495 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54496 }
54497 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54498 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54499 }
54500 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54501 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54502 }
54503 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54504 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54505 }
54506 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54507 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54508 }
54509 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54510 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54511 }
54512 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54513 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54514 }
54515 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54516 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54517 }
54518 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54519 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54520 }
54521 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54522 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54523 }
54524 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54525 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54526 }
54527 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54528 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54529 }
54530 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54531 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54532 }
54533 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54534 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54535 }
54536 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54537 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54538 }
54539 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54540 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54541 }
54542 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54543 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54544 }
54545 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54546 return (void *)((wxObject *) ((wxSizerItem *) x));
54547 }
54548 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54549 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54550 }
54551 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54552 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54553 }
54554 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54555 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54556 }
54557 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54558 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54559 }
54560 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54561 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54562 }
54563 static void *_p_wxSizerTo_p_wxObject(void *x) {
54564 return (void *)((wxObject *) ((wxSizer *) x));
54565 }
54566 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54567 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54568 }
54569 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54570 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54571 }
54572 static void *_p_wxEventTo_p_wxObject(void *x) {
54573 return (void *)((wxObject *) ((wxEvent *) x));
54574 }
54575 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54576 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54577 }
54578 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54579 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54580 }
54581 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54582 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54583 }
54584 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54586 }
54587 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54588 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54589 }
54590 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54591 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54592 }
54593 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54594 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54595 }
54596 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54597 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54598 }
54599 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54600 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54601 }
54602 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54603 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54604 }
54605 static void *_p_wxControlTo_p_wxObject(void *x) {
54606 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54607 }
54608 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54609 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54610 }
54611 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54612 return (void *)((wxObject *) ((wxFSFile *) x));
54613 }
54614 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54615 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54616 }
54617 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54618 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54619 }
54620 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54621 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54622 }
54623 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54624 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54625 }
54626 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54627 return (void *)((wxObject *) ((wxMenuItem *) x));
54628 }
54629 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54631 }
54632 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54633 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54634 }
54635 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54636 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54637 }
54638 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54639 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54640 }
54641 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54642 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54643 }
54644 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54645 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54646 }
54647 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54648 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54649 }
54650 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54651 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54652 }
54653 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54654 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54655 }
54656 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54657 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54658 }
54659 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54660 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54661 }
54662 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54663 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54664 }
54665 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54666 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54667 }
54668 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54669 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54670 }
54671 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54672 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54673 }
54674 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54675 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54676 }
54677 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54678 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54679 }
54680 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54681 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54682 }
54683 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54684 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54685 }
54686 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54687 return (void *)((wxObject *) ((wxImageHandler *) x));
54688 }
54689 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54690 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54691 }
54692 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54693 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54694 }
54695 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54696 return (void *)((wxObject *) ((wxEvtHandler *) x));
54697 }
54698 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54699 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54700 }
54701 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54702 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54703 }
54704 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54705 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54706 }
54707 static void *_p_wxImageTo_p_wxObject(void *x) {
54708 return (void *)((wxObject *) ((wxImage *) x));
54709 }
54710 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54711 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54712 }
54713 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54714 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54715 }
54716 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54717 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54718 }
54719 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54720 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54721 }
54722 static void *_p_wxWindowTo_p_wxObject(void *x) {
54723 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54724 }
54725 static void *_p_wxMenuTo_p_wxObject(void *x) {
54726 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54727 }
54728 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54729 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54730 }
54731 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54732 return (void *)((wxObject *) ((wxFileSystem *) x));
54733 }
54734 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54735 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54736 }
54737 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54738 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54739 }
54740 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54741 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54742 }
54743 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54744 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54745 }
54746 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54747 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54748 }
54749 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54750 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54751 }
54752 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54753 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54754 }
54755 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54756 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54757 }
54758 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54759 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54760 }
54761 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54762 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54763 }
54764 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54765 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54766 }
54767 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54768 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54769 }
54770 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54771 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54772 }
54773 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54774 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54775 }
54776 static void *_p_wxControlTo_p_wxWindow(void *x) {
54777 return (void *)((wxWindow *) ((wxControl *) x));
54778 }
54779 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54780 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54781 }
54782 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54783 return (void *)((wxWindow *) ((wxMenuBar *) x));
54784 }
54785 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54786 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54787 }
54788 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54789 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54790 }
54791 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54792 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54793 }
54794 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54795 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54796 }
54797 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54798 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54799 }
54800 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54801 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54802 }
54803 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54804 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54805 }
54806 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54807 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54808 }
54809 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54810 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54811 }
54812 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54813 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54814 }
54815 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54816 return (void *)((wxValidator *) ((wxPyValidator *) x));
54817 }
54818 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54820 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};
54821 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54922 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54923 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54924 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54925 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54926 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54927 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54928 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54929 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54930 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54931 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54932 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54933 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54934 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54935 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54936 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54937 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54938 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54939 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54940 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54941 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54942 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54943 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54944 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54945 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54946 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54947 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54948 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54949 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54950
54951 static swig_type_info *swig_type_initial[] = {
54952 &_swigt__p_buffer,
54953 &_swigt__p_char,
54954 &_swigt__p_form_ops_t,
54955 &_swigt__p_int,
54956 &_swigt__p_long,
54957 &_swigt__p_unsigned_char,
54958 &_swigt__p_unsigned_int,
54959 &_swigt__p_unsigned_long,
54960 &_swigt__p_wxANIHandler,
54961 &_swigt__p_wxAcceleratorEntry,
54962 &_swigt__p_wxAcceleratorTable,
54963 &_swigt__p_wxActivateEvent,
54964 &_swigt__p_wxAppTraits,
54965 &_swigt__p_wxArrayString,
54966 &_swigt__p_wxBMPHandler,
54967 &_swigt__p_wxBitmap,
54968 &_swigt__p_wxBoxSizer,
54969 &_swigt__p_wxButton,
54970 &_swigt__p_wxCURHandler,
54971 &_swigt__p_wxCaret,
54972 &_swigt__p_wxChildFocusEvent,
54973 &_swigt__p_wxClipboardTextEvent,
54974 &_swigt__p_wxCloseEvent,
54975 &_swigt__p_wxColour,
54976 &_swigt__p_wxCommandEvent,
54977 &_swigt__p_wxContextMenuEvent,
54978 &_swigt__p_wxControl,
54979 &_swigt__p_wxControlWithItems,
54980 &_swigt__p_wxCursor,
54981 &_swigt__p_wxDC,
54982 &_swigt__p_wxDateEvent,
54983 &_swigt__p_wxDateTime,
54984 &_swigt__p_wxDisplayChangedEvent,
54985 &_swigt__p_wxDropFilesEvent,
54986 &_swigt__p_wxDuplexMode,
54987 &_swigt__p_wxEraseEvent,
54988 &_swigt__p_wxEvent,
54989 &_swigt__p_wxEventLoop,
54990 &_swigt__p_wxEventLoopActivator,
54991 &_swigt__p_wxEvtHandler,
54992 &_swigt__p_wxFSFile,
54993 &_swigt__p_wxFileSystem,
54994 &_swigt__p_wxFileSystemHandler,
54995 &_swigt__p_wxFlexGridSizer,
54996 &_swigt__p_wxFocusEvent,
54997 &_swigt__p_wxFont,
54998 &_swigt__p_wxFrame,
54999 &_swigt__p_wxGBPosition,
55000 &_swigt__p_wxGBSizerItem,
55001 &_swigt__p_wxGBSpan,
55002 &_swigt__p_wxGIFHandler,
55003 &_swigt__p_wxGridBagSizer,
55004 &_swigt__p_wxGridSizer,
55005 &_swigt__p_wxHelpEvent__Origin,
55006 &_swigt__p_wxICOHandler,
55007 &_swigt__p_wxIconizeEvent,
55008 &_swigt__p_wxIdleEvent,
55009 &_swigt__p_wxImage,
55010 &_swigt__p_wxImageHandler,
55011 &_swigt__p_wxImageHistogram,
55012 &_swigt__p_wxImage_HSVValue,
55013 &_swigt__p_wxImage_RGBValue,
55014 &_swigt__p_wxIndividualLayoutConstraint,
55015 &_swigt__p_wxInitDialogEvent,
55016 &_swigt__p_wxInputStream,
55017 &_swigt__p_wxInternetFSHandler,
55018 &_swigt__p_wxItemContainer,
55019 &_swigt__p_wxJPEGHandler,
55020 &_swigt__p_wxKeyEvent,
55021 &_swigt__p_wxLayoutConstraints,
55022 &_swigt__p_wxMaximizeEvent,
55023 &_swigt__p_wxMemoryFSHandler,
55024 &_swigt__p_wxMenu,
55025 &_swigt__p_wxMenuBar,
55026 &_swigt__p_wxMenuBarBase,
55027 &_swigt__p_wxMenuEvent,
55028 &_swigt__p_wxMenuItem,
55029 &_swigt__p_wxMouseCaptureChangedEvent,
55030 &_swigt__p_wxMouseCaptureLostEvent,
55031 &_swigt__p_wxMouseEvent,
55032 &_swigt__p_wxMoveEvent,
55033 &_swigt__p_wxNavigationKeyEvent,
55034 &_swigt__p_wxNcPaintEvent,
55035 &_swigt__p_wxNotifyEvent,
55036 &_swigt__p_wxObject,
55037 &_swigt__p_wxOutputStream,
55038 &_swigt__p_wxPCXHandler,
55039 &_swigt__p_wxPNGHandler,
55040 &_swigt__p_wxPNMHandler,
55041 &_swigt__p_wxPaintEvent,
55042 &_swigt__p_wxPaletteChangedEvent,
55043 &_swigt__p_wxPaperSize,
55044 &_swigt__p_wxPoint,
55045 &_swigt__p_wxPoint2D,
55046 &_swigt__p_wxPropagateOnce,
55047 &_swigt__p_wxPropagationDisabler,
55048 &_swigt__p_wxPyApp,
55049 &_swigt__p_wxPyCommandEvent,
55050 &_swigt__p_wxPyDropTarget,
55051 &_swigt__p_wxPyEvent,
55052 &_swigt__p_wxPyFileSystemHandler,
55053 &_swigt__p_wxPyImageHandler,
55054 &_swigt__p_wxPyInputStream,
55055 &_swigt__p_wxPySizer,
55056 &_swigt__p_wxPyValidator,
55057 &_swigt__p_wxQuantize,
55058 &_swigt__p_wxQueryNewPaletteEvent,
55059 &_swigt__p_wxRealPoint,
55060 &_swigt__p_wxRect,
55061 &_swigt__p_wxRegion,
55062 &_swigt__p_wxScrollEvent,
55063 &_swigt__p_wxScrollWinEvent,
55064 &_swigt__p_wxSetCursorEvent,
55065 &_swigt__p_wxShowEvent,
55066 &_swigt__p_wxSize,
55067 &_swigt__p_wxSizeEvent,
55068 &_swigt__p_wxSizer,
55069 &_swigt__p_wxSizerItem,
55070 &_swigt__p_wxStaticBox,
55071 &_swigt__p_wxStaticBoxSizer,
55072 &_swigt__p_wxStdDialogButtonSizer,
55073 &_swigt__p_wxSysColourChangedEvent,
55074 &_swigt__p_wxTIFFHandler,
55075 &_swigt__p_wxToolTip,
55076 &_swigt__p_wxUpdateUIEvent,
55077 &_swigt__p_wxValidator,
55078 &_swigt__p_wxVisualAttributes,
55079 &_swigt__p_wxWindow,
55080 &_swigt__p_wxWindowCreateEvent,
55081 &_swigt__p_wxWindowDestroyEvent,
55082 &_swigt__p_wxXPMHandler,
55083 &_swigt__p_wxZipFSHandler,
55084 };
55085
55086 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55094 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55095 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55100 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}};
55101 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55102 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}};
55103 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55104 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}};
55105 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55110 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}};
55111 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55112 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}};
55113 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55122 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}};
55123 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55124 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55125 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}};
55126 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55128 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}};
55129 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}};
55130 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55138 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}};
55139 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55140 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}};
55141 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55143 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55144 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}};
55145 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55152 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}};
55153 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55170 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}};
55171 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55174 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55175 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55176 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55183 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55184 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55185 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55186 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55190 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55191 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55192 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55193 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55194 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55195 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55196 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55197 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55198 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55199 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55200 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55201 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55202 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}};
55203 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}};
55204 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55205 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55206 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55207 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55208 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55209 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55210 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55211 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}};
55212 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55213 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}};
55214 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55215 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55216 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55217 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55218
55219 static swig_cast_info *swig_cast_initial[] = {
55220 _swigc__p_buffer,
55221 _swigc__p_char,
55222 _swigc__p_form_ops_t,
55223 _swigc__p_int,
55224 _swigc__p_long,
55225 _swigc__p_unsigned_char,
55226 _swigc__p_unsigned_int,
55227 _swigc__p_unsigned_long,
55228 _swigc__p_wxANIHandler,
55229 _swigc__p_wxAcceleratorEntry,
55230 _swigc__p_wxAcceleratorTable,
55231 _swigc__p_wxActivateEvent,
55232 _swigc__p_wxAppTraits,
55233 _swigc__p_wxArrayString,
55234 _swigc__p_wxBMPHandler,
55235 _swigc__p_wxBitmap,
55236 _swigc__p_wxBoxSizer,
55237 _swigc__p_wxButton,
55238 _swigc__p_wxCURHandler,
55239 _swigc__p_wxCaret,
55240 _swigc__p_wxChildFocusEvent,
55241 _swigc__p_wxClipboardTextEvent,
55242 _swigc__p_wxCloseEvent,
55243 _swigc__p_wxColour,
55244 _swigc__p_wxCommandEvent,
55245 _swigc__p_wxContextMenuEvent,
55246 _swigc__p_wxControl,
55247 _swigc__p_wxControlWithItems,
55248 _swigc__p_wxCursor,
55249 _swigc__p_wxDC,
55250 _swigc__p_wxDateEvent,
55251 _swigc__p_wxDateTime,
55252 _swigc__p_wxDisplayChangedEvent,
55253 _swigc__p_wxDropFilesEvent,
55254 _swigc__p_wxDuplexMode,
55255 _swigc__p_wxEraseEvent,
55256 _swigc__p_wxEvent,
55257 _swigc__p_wxEventLoop,
55258 _swigc__p_wxEventLoopActivator,
55259 _swigc__p_wxEvtHandler,
55260 _swigc__p_wxFSFile,
55261 _swigc__p_wxFileSystem,
55262 _swigc__p_wxFileSystemHandler,
55263 _swigc__p_wxFlexGridSizer,
55264 _swigc__p_wxFocusEvent,
55265 _swigc__p_wxFont,
55266 _swigc__p_wxFrame,
55267 _swigc__p_wxGBPosition,
55268 _swigc__p_wxGBSizerItem,
55269 _swigc__p_wxGBSpan,
55270 _swigc__p_wxGIFHandler,
55271 _swigc__p_wxGridBagSizer,
55272 _swigc__p_wxGridSizer,
55273 _swigc__p_wxHelpEvent__Origin,
55274 _swigc__p_wxICOHandler,
55275 _swigc__p_wxIconizeEvent,
55276 _swigc__p_wxIdleEvent,
55277 _swigc__p_wxImage,
55278 _swigc__p_wxImageHandler,
55279 _swigc__p_wxImageHistogram,
55280 _swigc__p_wxImage_HSVValue,
55281 _swigc__p_wxImage_RGBValue,
55282 _swigc__p_wxIndividualLayoutConstraint,
55283 _swigc__p_wxInitDialogEvent,
55284 _swigc__p_wxInputStream,
55285 _swigc__p_wxInternetFSHandler,
55286 _swigc__p_wxItemContainer,
55287 _swigc__p_wxJPEGHandler,
55288 _swigc__p_wxKeyEvent,
55289 _swigc__p_wxLayoutConstraints,
55290 _swigc__p_wxMaximizeEvent,
55291 _swigc__p_wxMemoryFSHandler,
55292 _swigc__p_wxMenu,
55293 _swigc__p_wxMenuBar,
55294 _swigc__p_wxMenuBarBase,
55295 _swigc__p_wxMenuEvent,
55296 _swigc__p_wxMenuItem,
55297 _swigc__p_wxMouseCaptureChangedEvent,
55298 _swigc__p_wxMouseCaptureLostEvent,
55299 _swigc__p_wxMouseEvent,
55300 _swigc__p_wxMoveEvent,
55301 _swigc__p_wxNavigationKeyEvent,
55302 _swigc__p_wxNcPaintEvent,
55303 _swigc__p_wxNotifyEvent,
55304 _swigc__p_wxObject,
55305 _swigc__p_wxOutputStream,
55306 _swigc__p_wxPCXHandler,
55307 _swigc__p_wxPNGHandler,
55308 _swigc__p_wxPNMHandler,
55309 _swigc__p_wxPaintEvent,
55310 _swigc__p_wxPaletteChangedEvent,
55311 _swigc__p_wxPaperSize,
55312 _swigc__p_wxPoint,
55313 _swigc__p_wxPoint2D,
55314 _swigc__p_wxPropagateOnce,
55315 _swigc__p_wxPropagationDisabler,
55316 _swigc__p_wxPyApp,
55317 _swigc__p_wxPyCommandEvent,
55318 _swigc__p_wxPyDropTarget,
55319 _swigc__p_wxPyEvent,
55320 _swigc__p_wxPyFileSystemHandler,
55321 _swigc__p_wxPyImageHandler,
55322 _swigc__p_wxPyInputStream,
55323 _swigc__p_wxPySizer,
55324 _swigc__p_wxPyValidator,
55325 _swigc__p_wxQuantize,
55326 _swigc__p_wxQueryNewPaletteEvent,
55327 _swigc__p_wxRealPoint,
55328 _swigc__p_wxRect,
55329 _swigc__p_wxRegion,
55330 _swigc__p_wxScrollEvent,
55331 _swigc__p_wxScrollWinEvent,
55332 _swigc__p_wxSetCursorEvent,
55333 _swigc__p_wxShowEvent,
55334 _swigc__p_wxSize,
55335 _swigc__p_wxSizeEvent,
55336 _swigc__p_wxSizer,
55337 _swigc__p_wxSizerItem,
55338 _swigc__p_wxStaticBox,
55339 _swigc__p_wxStaticBoxSizer,
55340 _swigc__p_wxStdDialogButtonSizer,
55341 _swigc__p_wxSysColourChangedEvent,
55342 _swigc__p_wxTIFFHandler,
55343 _swigc__p_wxToolTip,
55344 _swigc__p_wxUpdateUIEvent,
55345 _swigc__p_wxValidator,
55346 _swigc__p_wxVisualAttributes,
55347 _swigc__p_wxWindow,
55348 _swigc__p_wxWindowCreateEvent,
55349 _swigc__p_wxWindowDestroyEvent,
55350 _swigc__p_wxXPMHandler,
55351 _swigc__p_wxZipFSHandler,
55352 };
55353
55354
55355 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55356
55357 static swig_const_info swig_const_table[] = {
55358 {0, 0, 0, 0.0, 0, 0}};
55359
55360 #ifdef __cplusplus
55361 }
55362 #endif
55363 /* -----------------------------------------------------------------------------
55364 * Type initialization:
55365 * This problem is tough by the requirement that no dynamic
55366 * memory is used. Also, since swig_type_info structures store pointers to
55367 * swig_cast_info structures and swig_cast_info structures store pointers back
55368 * to swig_type_info structures, we need some lookup code at initialization.
55369 * The idea is that swig generates all the structures that are needed.
55370 * The runtime then collects these partially filled structures.
55371 * The SWIG_InitializeModule function takes these initial arrays out of
55372 * swig_module, and does all the lookup, filling in the swig_module.types
55373 * array with the correct data and linking the correct swig_cast_info
55374 * structures together.
55375 *
55376 * The generated swig_type_info structures are assigned staticly to an initial
55377 * array. We just loop though that array, and handle each type individually.
55378 * First we lookup if this type has been already loaded, and if so, use the
55379 * loaded structure instead of the generated one. Then we have to fill in the
55380 * cast linked list. The cast data is initially stored in something like a
55381 * two-dimensional array. Each row corresponds to a type (there are the same
55382 * number of rows as there are in the swig_type_initial array). Each entry in
55383 * a column is one of the swig_cast_info structures for that type.
55384 * The cast_initial array is actually an array of arrays, because each row has
55385 * a variable number of columns. So to actually build the cast linked list,
55386 * we find the array of casts associated with the type, and loop through it
55387 * adding the casts to the list. The one last trick we need to do is making
55388 * sure the type pointer in the swig_cast_info struct is correct.
55389 *
55390 * First off, we lookup the cast->type name to see if it is already loaded.
55391 * There are three cases to handle:
55392 * 1) If the cast->type has already been loaded AND the type we are adding
55393 * casting info to has not been loaded (it is in this module), THEN we
55394 * replace the cast->type pointer with the type pointer that has already
55395 * been loaded.
55396 * 2) If BOTH types (the one we are adding casting info to, and the
55397 * cast->type) are loaded, THEN the cast info has already been loaded by
55398 * the previous module so we just ignore it.
55399 * 3) Finally, if cast->type has not already been loaded, then we add that
55400 * swig_cast_info to the linked list (because the cast->type) pointer will
55401 * be correct.
55402 * ----------------------------------------------------------------------------- */
55403
55404 #ifdef __cplusplus
55405 extern "C" {
55406 #if 0
55407 } /* c-mode */
55408 #endif
55409 #endif
55410
55411 #if 0
55412 #define SWIGRUNTIME_DEBUG
55413 #endif
55414
55415 SWIGRUNTIME void
55416 SWIG_InitializeModule(void *clientdata) {
55417 size_t i;
55418 swig_module_info *module_head;
55419 static int init_run = 0;
55420
55421 clientdata = clientdata;
55422
55423 if (init_run) return;
55424 init_run = 1;
55425
55426 /* Initialize the swig_module */
55427 swig_module.type_initial = swig_type_initial;
55428 swig_module.cast_initial = swig_cast_initial;
55429
55430 /* Try and load any already created modules */
55431 module_head = SWIG_GetModule(clientdata);
55432 if (module_head) {
55433 swig_module.next = module_head->next;
55434 module_head->next = &swig_module;
55435 } else {
55436 /* This is the first module loaded */
55437 swig_module.next = &swig_module;
55438 SWIG_SetModule(clientdata, &swig_module);
55439 }
55440
55441 /* Now work on filling in swig_module.types */
55442 #ifdef SWIGRUNTIME_DEBUG
55443 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55444 #endif
55445 for (i = 0; i < swig_module.size; ++i) {
55446 swig_type_info *type = 0;
55447 swig_type_info *ret;
55448 swig_cast_info *cast;
55449
55450 #ifdef SWIGRUNTIME_DEBUG
55451 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55452 #endif
55453
55454 /* if there is another module already loaded */
55455 if (swig_module.next != &swig_module) {
55456 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55457 }
55458 if (type) {
55459 /* Overwrite clientdata field */
55460 #ifdef SWIGRUNTIME_DEBUG
55461 printf("SWIG_InitializeModule: found type %s\n", type->name);
55462 #endif
55463 if (swig_module.type_initial[i]->clientdata) {
55464 type->clientdata = swig_module.type_initial[i]->clientdata;
55465 #ifdef SWIGRUNTIME_DEBUG
55466 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55467 #endif
55468 }
55469 } else {
55470 type = swig_module.type_initial[i];
55471 }
55472
55473 /* Insert casting types */
55474 cast = swig_module.cast_initial[i];
55475 while (cast->type) {
55476 /* Don't need to add information already in the list */
55477 ret = 0;
55478 #ifdef SWIGRUNTIME_DEBUG
55479 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55480 #endif
55481 if (swig_module.next != &swig_module) {
55482 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55483 #ifdef SWIGRUNTIME_DEBUG
55484 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55485 #endif
55486 }
55487 if (ret) {
55488 if (type == swig_module.type_initial[i]) {
55489 #ifdef SWIGRUNTIME_DEBUG
55490 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55491 #endif
55492 cast->type = ret;
55493 ret = 0;
55494 } else {
55495 /* Check for casting already in the list */
55496 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55497 #ifdef SWIGRUNTIME_DEBUG
55498 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55499 #endif
55500 if (!ocast) ret = 0;
55501 }
55502 }
55503
55504 if (!ret) {
55505 #ifdef SWIGRUNTIME_DEBUG
55506 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55507 #endif
55508 if (type->cast) {
55509 type->cast->prev = cast;
55510 cast->next = type->cast;
55511 }
55512 type->cast = cast;
55513 }
55514 cast++;
55515 }
55516 /* Set entry in modules->types array equal to the type */
55517 swig_module.types[i] = type;
55518 }
55519 swig_module.types[i] = 0;
55520
55521 #ifdef SWIGRUNTIME_DEBUG
55522 printf("**** SWIG_InitializeModule: Cast List ******\n");
55523 for (i = 0; i < swig_module.size; ++i) {
55524 int j = 0;
55525 swig_cast_info *cast = swig_module.cast_initial[i];
55526 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55527 while (cast->type) {
55528 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55529 cast++;
55530 ++j;
55531 }
55532 printf("---- Total casts: %d\n",j);
55533 }
55534 printf("**** SWIG_InitializeModule: Cast List ******\n");
55535 #endif
55536 }
55537
55538 /* This function will propagate the clientdata field of type to
55539 * any new swig_type_info structures that have been added into the list
55540 * of equivalent types. It is like calling
55541 * SWIG_TypeClientData(type, clientdata) a second time.
55542 */
55543 SWIGRUNTIME void
55544 SWIG_PropagateClientData(void) {
55545 size_t i;
55546 swig_cast_info *equiv;
55547 static int init_run = 0;
55548
55549 if (init_run) return;
55550 init_run = 1;
55551
55552 for (i = 0; i < swig_module.size; i++) {
55553 if (swig_module.types[i]->clientdata) {
55554 equiv = swig_module.types[i]->cast;
55555 while (equiv) {
55556 if (!equiv->converter) {
55557 if (equiv->type && !equiv->type->clientdata)
55558 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55559 }
55560 equiv = equiv->next;
55561 }
55562 }
55563 }
55564 }
55565
55566 #ifdef __cplusplus
55567 #if 0
55568 {
55569 /* c-mode */
55570 #endif
55571 }
55572 #endif
55573
55574
55575
55576 #ifdef __cplusplus
55577 extern "C" {
55578 #endif
55579
55580 /* Python-specific SWIG API */
55581 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55582 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55583 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55584
55585 /* -----------------------------------------------------------------------------
55586 * global variable support code.
55587 * ----------------------------------------------------------------------------- */
55588
55589 typedef struct swig_globalvar {
55590 char *name; /* Name of global variable */
55591 PyObject *(*get_attr)(void); /* Return the current value */
55592 int (*set_attr)(PyObject *); /* Set the value */
55593 struct swig_globalvar *next;
55594 } swig_globalvar;
55595
55596 typedef struct swig_varlinkobject {
55597 PyObject_HEAD
55598 swig_globalvar *vars;
55599 } swig_varlinkobject;
55600
55601 SWIGINTERN PyObject *
55602 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55603 return PyString_FromString("<Swig global variables>");
55604 }
55605
55606 SWIGINTERN PyObject *
55607 swig_varlink_str(swig_varlinkobject *v) {
55608 PyObject *str = PyString_FromString("(");
55609 swig_globalvar *var;
55610 for (var = v->vars; var; var=var->next) {
55611 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55612 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55613 }
55614 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55615 return str;
55616 }
55617
55618 SWIGINTERN int
55619 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55620 PyObject *str = swig_varlink_str(v);
55621 fprintf(fp,"Swig global variables ");
55622 fprintf(fp,"%s\n", PyString_AsString(str));
55623 Py_DECREF(str);
55624 return 0;
55625 }
55626
55627 SWIGINTERN void
55628 swig_varlink_dealloc(swig_varlinkobject *v) {
55629 swig_globalvar *var = v->vars;
55630 while (var) {
55631 swig_globalvar *n = var->next;
55632 free(var->name);
55633 free(var);
55634 var = n;
55635 }
55636 }
55637
55638 SWIGINTERN PyObject *
55639 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55640 PyObject *res = NULL;
55641 swig_globalvar *var = v->vars;
55642 while (var) {
55643 if (strcmp(var->name,n) == 0) {
55644 res = (*var->get_attr)();
55645 break;
55646 }
55647 var = var->next;
55648 }
55649 if (res == NULL && !PyErr_Occurred()) {
55650 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55651 }
55652 return res;
55653 }
55654
55655 SWIGINTERN int
55656 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55657 int res = 1;
55658 swig_globalvar *var = v->vars;
55659 while (var) {
55660 if (strcmp(var->name,n) == 0) {
55661 res = (*var->set_attr)(p);
55662 break;
55663 }
55664 var = var->next;
55665 }
55666 if (res == 1 && !PyErr_Occurred()) {
55667 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55668 }
55669 return res;
55670 }
55671
55672 SWIGINTERN PyTypeObject*
55673 swig_varlink_type(void) {
55674 static char varlink__doc__[] = "Swig var link object";
55675 static PyTypeObject varlink_type;
55676 static int type_init = 0;
55677 if (!type_init) {
55678 const PyTypeObject tmp
55679 = {
55680 PyObject_HEAD_INIT(NULL)
55681 0, /* Number of items in variable part (ob_size) */
55682 (char *)"swigvarlink", /* Type name (tp_name) */
55683 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55684 0, /* Itemsize (tp_itemsize) */
55685 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55686 (printfunc) swig_varlink_print, /* Print (tp_print) */
55687 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55688 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55689 0, /* tp_compare */
55690 (reprfunc) swig_varlink_repr, /* tp_repr */
55691 0, /* tp_as_number */
55692 0, /* tp_as_sequence */
55693 0, /* tp_as_mapping */
55694 0, /* tp_hash */
55695 0, /* tp_call */
55696 (reprfunc)swig_varlink_str, /* tp_str */
55697 0, /* tp_getattro */
55698 0, /* tp_setattro */
55699 0, /* tp_as_buffer */
55700 0, /* tp_flags */
55701 varlink__doc__, /* tp_doc */
55702 0, /* tp_traverse */
55703 0, /* tp_clear */
55704 0, /* tp_richcompare */
55705 0, /* tp_weaklistoffset */
55706 #if PY_VERSION_HEX >= 0x02020000
55707 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55708 #endif
55709 #if PY_VERSION_HEX >= 0x02030000
55710 0, /* tp_del */
55711 #endif
55712 #ifdef COUNT_ALLOCS
55713 0,0,0,0 /* tp_alloc -> tp_next */
55714 #endif
55715 };
55716 varlink_type = tmp;
55717 varlink_type.ob_type = &PyType_Type;
55718 type_init = 1;
55719 }
55720 return &varlink_type;
55721 }
55722
55723 /* Create a variable linking object for use later */
55724 SWIGINTERN PyObject *
55725 SWIG_Python_newvarlink(void) {
55726 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55727 if (result) {
55728 result->vars = 0;
55729 }
55730 return ((PyObject*) result);
55731 }
55732
55733 SWIGINTERN void
55734 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55735 swig_varlinkobject *v = (swig_varlinkobject *) p;
55736 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55737 if (gv) {
55738 size_t size = strlen(name)+1;
55739 gv->name = (char *)malloc(size);
55740 if (gv->name) {
55741 strncpy(gv->name,name,size);
55742 gv->get_attr = get_attr;
55743 gv->set_attr = set_attr;
55744 gv->next = v->vars;
55745 }
55746 }
55747 v->vars = gv;
55748 }
55749
55750 SWIGINTERN PyObject *
55751 SWIG_globals() {
55752 static PyObject *_SWIG_globals = 0;
55753 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55754 return _SWIG_globals;
55755 }
55756
55757 /* -----------------------------------------------------------------------------
55758 * constants/methods manipulation
55759 * ----------------------------------------------------------------------------- */
55760
55761 /* Install Constants */
55762 SWIGINTERN void
55763 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55764 PyObject *obj = 0;
55765 size_t i;
55766 for (i = 0; constants[i].type; ++i) {
55767 switch(constants[i].type) {
55768 case SWIG_PY_POINTER:
55769 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55770 break;
55771 case SWIG_PY_BINARY:
55772 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55773 break;
55774 default:
55775 obj = 0;
55776 break;
55777 }
55778 if (obj) {
55779 PyDict_SetItemString(d, constants[i].name, obj);
55780 Py_DECREF(obj);
55781 }
55782 }
55783 }
55784
55785 /* -----------------------------------------------------------------------------*/
55786 /* Fix SwigMethods to carry the callback ptrs when needed */
55787 /* -----------------------------------------------------------------------------*/
55788
55789 SWIGINTERN void
55790 SWIG_Python_FixMethods(PyMethodDef *methods,
55791 swig_const_info *const_table,
55792 swig_type_info **types,
55793 swig_type_info **types_initial) {
55794 size_t i;
55795 for (i = 0; methods[i].ml_name; ++i) {
55796 const char *c = methods[i].ml_doc;
55797 if (c && (c = strstr(c, "swig_ptr: "))) {
55798 int j;
55799 swig_const_info *ci = 0;
55800 const char *name = c + 10;
55801 for (j = 0; const_table[j].type; ++j) {
55802 if (strncmp(const_table[j].name, name,
55803 strlen(const_table[j].name)) == 0) {
55804 ci = &(const_table[j]);
55805 break;
55806 }
55807 }
55808 if (ci) {
55809 size_t shift = (ci->ptype) - types;
55810 swig_type_info *ty = types_initial[shift];
55811 size_t ldoc = (c - methods[i].ml_doc);
55812 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55813 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55814 if (ndoc) {
55815 char *buff = ndoc;
55816 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55817 if (ptr) {
55818 strncpy(buff, methods[i].ml_doc, ldoc);
55819 buff += ldoc;
55820 strncpy(buff, "swig_ptr: ", 10);
55821 buff += 10;
55822 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55823 methods[i].ml_doc = ndoc;
55824 }
55825 }
55826 }
55827 }
55828 }
55829 }
55830
55831 #ifdef __cplusplus
55832 }
55833 #endif
55834
55835 /* -----------------------------------------------------------------------------*
55836 * Partial Init method
55837 * -----------------------------------------------------------------------------*/
55838
55839 #ifdef __cplusplus
55840 extern "C"
55841 #endif
55842 SWIGEXPORT void SWIG_init(void) {
55843 PyObject *m, *d;
55844
55845 /* Fix SwigMethods to carry the callback ptrs when needed */
55846 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55847
55848 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55849 d = PyModule_GetDict(m);
55850
55851 SWIG_InitializeModule(0);
55852 SWIG_InstallConstants(d,swig_const_table);
55853
55854
55855
55856 #ifndef wxPyUSE_EXPORT
55857 // Make our API structure a CObject so other modules can import it
55858 // from this module.
55859 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55860 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55861 Py_XDECREF(cobj);
55862 #endif
55863
55864 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55865 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55866 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55867 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55868 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55869 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55870 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55871 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55872 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55873 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55874 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55875 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55876 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55877 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55878 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55879 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55880 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55881 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55882 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55883 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55884 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55885 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55886 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55887 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55888 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55889 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55890 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55891 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55892 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55893 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55894 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55895 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55896 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55897 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55898 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55899 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55900 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55901 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55902 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55903 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55904 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55905 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55906 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55907 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55908 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55909 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55910 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55911 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55912 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55913 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55914 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55915 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55916 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55917 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55918 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55919 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55920 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55921 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55922 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55923 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55924 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55925 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55926 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55927 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55928 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55929 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55930 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55931 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55932 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55933 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55934 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55935 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55936 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55937 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55938 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55939 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55940 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55941 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55942 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55943 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55944 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55945 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55946 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55947 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55948 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55949 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55950 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55951 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55952 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55953 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55954 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55955 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55956 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55957 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55958 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55959 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55960 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55961 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55962 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55963 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55964 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55965 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55966 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55967 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55968 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55969 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55970 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55971 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55972 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55973 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55974 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55975 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55976 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55977 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55978 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55979 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55980 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55981 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55982 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55983 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55984 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55985 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55986 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55987 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55988 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55989 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55990 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55991 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55992 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55993 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55994 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55995 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55996 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55997 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55998 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55999 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56000 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56001 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56002 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56003 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56004 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56005 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56006 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56007 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56008 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56009 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56010 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56011 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56012 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56013 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56014 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56015 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56016 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56017 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56018 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56019 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56020 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56021 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56022 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56023 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56024 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56025 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56026 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56027 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56028 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56029 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56030 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56031 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56032 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56033 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56034 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56035 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56036 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56037 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56038 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56039 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56040 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56041 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56042 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56043 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56044 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56045 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56046 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56047 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56048 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56049 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56050 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56051 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56052 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56053 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56054 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56055 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56056 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56057 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56058 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56059 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56060 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56061 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56062 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56063 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56064 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56065 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56066 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56067 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56068 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56069 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56070 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56071 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56072 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56073 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56074 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56075 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56076 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56077 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56078 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56079 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56080 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56081 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56082 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56083 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56084 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56085 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56086 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56087 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56088 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56089 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56090 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56091 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56092 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56093 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56094 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56095 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56096 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56097 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56098 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56099 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56100 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56101 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56102 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56103 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56104 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56105 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56106 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56107 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56108 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56109 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56110 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56111 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56112 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56113 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56114 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56115 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56116 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56117 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56118 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56119 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56120 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56121 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56122 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56123 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56124 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56125 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56126 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56127 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56128 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56129 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56130 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56131 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56132 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56133 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56134 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56135 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56136 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56137 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56138 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56139 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56140 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56141 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56142 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56143 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56144 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56145 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56146 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56147 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56148 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56149 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56150 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56151 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56152 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56153 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56154 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56155 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56156 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56157 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56158 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56159 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56160 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56161 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56162 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56163 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56164 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56165 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56166 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56167 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56168 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56169 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56170 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56171 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56172 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56173 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56174 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56175 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56176 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56177 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56178 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56179 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56180 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56181 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56182 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56183 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56184 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56185 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56186 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56187 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56188 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56189 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56190 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56191 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56192 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56193 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56194 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56195 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56196 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56197 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56198 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56199 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56200 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56201 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56202 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56203 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56204 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56205 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56206 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56207 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56208 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56209 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56210 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56211 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56212 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56213 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56214 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56215 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56216 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56217 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56218 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56219 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56220 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56221 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56222 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56223 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56224 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56225 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56226 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56227 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56228 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56229 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56230 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56231 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56232 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56233 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56234 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56235 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56236 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56237 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56238 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56239 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56240 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56241 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56242 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56243 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56244 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56245 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56246 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56247 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56248 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56249 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56250 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56251 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56252 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56253 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56254 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56255 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56256 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56257 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56258 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56259 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56260 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56261 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56262 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56264 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56265 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56266 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56267 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56268 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56269 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56270 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56271 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56272 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56273 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56274 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56275 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56276 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56277 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56278 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56279 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56280 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56281 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56282 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56283 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56284 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56285 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56286 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56287 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56288 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56289 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56290 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56291 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56292 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56293 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56294 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56295 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56296 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56297 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56298 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56299 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56300 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56301 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56302 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56303 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56304 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56305 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56306 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56307 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56308 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56309 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56310 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56311 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56312 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56313 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56314 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56315 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56316 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56317 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56318 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56319 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56320 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56321 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56322 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56323 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56324 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56325 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56326 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56327 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56328 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56329 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56330 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56331 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56332 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56333 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56334 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56335 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56336 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56337 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56338 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56339 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56340 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56341 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56342 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56343 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56344 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56345 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56346 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56347 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56348 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56349 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56350 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56351 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56352 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56353 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56354 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56355 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56356 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56357 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56358 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56359 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56360 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56361 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56362 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56363 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56364 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56365 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56366 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56367 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56368 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56369 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56370 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56371 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56372 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56373 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56374 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56375 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56376 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56377 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56378 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56379 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56380 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56381 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56382 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56383 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56384 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56385 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56386 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56387 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56388 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56389 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56390 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56391 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56392 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56393 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56394 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56395 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56396 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56397 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56398 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56405 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56407 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56408 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56409 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56410 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56411 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56412 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56413 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56414 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56415 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56416 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56417 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56418 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56419 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56420 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56421 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56422 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56423 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56424 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56425 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56426 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56427 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56428 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56429 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56430 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56431 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56432 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56433 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56434 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56435 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56436 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56437 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56438 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56439 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56440 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56441 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56442 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56443 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56444 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56445 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56446 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56447 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56448 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56449 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56450 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56451 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56452 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56453 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56454 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56455 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56456 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56457 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56458 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56459 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56460 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56461 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56462 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56463 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56464 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56465 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56466 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56467 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56468 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56469 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56470 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56471 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56472 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56473 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56474 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56475 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56476 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56477 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56478 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56479 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56480 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56481 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56482 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56483 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56484 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56485 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56486 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56487 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56488 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56489 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56490 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56491 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56492 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56493 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56494 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56495 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56496 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56497 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56498 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56499 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56500 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56501 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56502 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56503 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56504 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56505 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56506 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56507 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56508 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56509 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56510 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56511 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56512 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56513 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56514 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56515 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56516 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56517 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56518 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56519 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56520 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56521 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56522 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56523 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56524 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56526 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56527 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56528 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56529
56530 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56531
56532
56533 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56534
56535 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56536 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56537 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56538 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56539 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56540 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56541 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56542 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56543 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56544 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56545 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56546 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56547 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56548 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56549 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56550 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56551 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56552 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56553 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56554 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56555 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56556 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56557 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56558 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56559 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56560 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56561 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56562 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56563 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56564 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56565 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56566 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56567 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56568 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56569 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56570 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56571 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56572 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56573 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56574 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56575 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56576 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56577 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56578 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56579 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56580 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56581 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56582 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56583 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56584 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56585 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56586 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56587 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56588 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56589 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56590 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56591 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56592 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56593 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56594 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56595 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56596 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56597 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56598 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56599 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56600 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56601 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56602 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56603 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56604 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56605 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56606 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56607 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56608 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56609 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56610 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56611 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56612 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56613 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56614 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56615 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56616 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56617 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56618 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56619 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56620 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56621 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56622 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56623 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56624 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56625 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56626 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56627 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56628 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56629 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56630 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56631 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56632 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56633 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56634 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56635 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56636 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56637 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56638 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56639 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56640 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56641 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56642 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56643 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56644 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56645 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56646 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56647 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56648 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56649 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56650 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56651 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56652 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56653 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56654 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56655 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56656 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56657 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56658 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56659 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56660 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56661 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56662 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56663 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56664 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56665 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56666 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56667 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56668 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56669 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56670 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56671 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56672 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56673 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56674 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56675 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56676 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56677 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56678 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56679 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56680 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56681 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56682 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56683 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56684 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56685 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56686 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56687 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56688 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56689 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56690 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56691 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56692 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56693 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56694 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56695 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56696 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56697 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56698 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56699 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56700 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56701 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56702 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56703 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56704 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56705 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56706 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56707 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56708 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56709 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56710 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56711 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56712 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56713 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56714 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56715 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56716 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56717 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56718 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56719 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56720 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56721 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56722 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56723 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56724 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56725 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56726 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56727 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56728 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56729 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56730 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56731 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56732 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56733 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56734 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56735 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56736 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56737 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56738 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56739 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56740 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56741 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56742
56743 // Initialize threading, some globals and such
56744 __wxPyPreStart(d);
56745
56746
56747 // Although these are defined in __version__ they need to be here too so
56748 // that an assert can be done to ensure that the wxPython and the wxWindows
56749 // versions match.
56750 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56751 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56752 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56753
56754 }
56755
wxWidgets (Impactor)